@sentry/bundler-plugin-core 0.0.1-alpha.0 → 0.1.0

package/dist/esm/index.js

@@ -1,38 +1,8 @@
 import { createUnplugin } from 'unplugin';
 import MagicString from 'magic-string';
-import * as child_process from 'child_process';
-import axios, { AxiosError } from 'axios';
-import FormData from 'form-data';
 import { NodeClient, Integrations, defaultStackParser, makeNodeTransport, Hub, makeMain } from '@sentry/node';
-import path from 'path';
-import fs from 'fs';
 import '@sentry/tracing';
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  return target;
-}
+import SentryCli from '@sentry/cli';
 
 function _regeneratorRuntime() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
@@ -379,6 +349,16 @@ function _regeneratorRuntime() {
   }, exports;
 }
 
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg);
@@ -415,85 +395,565 @@ function _asyncToGenerator(fn) {
   };
 }
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
+/** Internal global with common properties and Sentry extensions  */
+
+// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
+// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
+// core-js has the following licence:
+//
+// Copyright (c) 2014-2022 Denis Pushkarev
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/** Returns 'obj' if it's the global object, otherwise returns undefined */
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : undefined;
+}
+
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ =
+  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
+  // eslint-disable-next-line no-restricted-globals
+  (typeof window == 'object' && isGlobalObj(window)) ||
+  (typeof self == 'object' && isGlobalObj(self)) ||
+  (typeof global == 'object' && isGlobalObj(global)) ||
+  (function () {
+    return this;
+  })() ||
+  {};
+
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
+/**
+ * Returns a global singleton contained in the global `__SENTRY__` object.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
+
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const originalConsole = GLOBAL_OBJ.console ;
+  const wrappedLevels = {};
+
+  // Restore all wrapped console methods
+  CONSOLE_LEVELS.forEach(level => {
+    // TODO(v7): Remove this check as it's only needed for Node 6
+    const originalWrappedFunc =
+      originalConsole[level] && (originalConsole[level] ).__sentry_original__;
+    if (level in originalConsole && originalWrappedFunc) {
+      wrappedLevels[level] = originalConsole[level] ;
+      originalConsole[level] = originalWrappedFunc ;
+    }
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    Object.keys(wrappedLevels).forEach(level => {
+      originalConsole[level] = wrappedLevels[level ];
+    });
+  }
+}
+
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
     });
   } else {
-    obj[key] = value;
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
+let logger;
+if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+  logger = getGlobalSingleton('logger', makeLogger);
+} else {
+  logger = makeLogger();
+}
+
+/*
+ * This module exists for optimizations in the build process through rollup and terser.  We define some global
+ * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+ * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+ * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+ * `logger` and preventing node-related code from appearing in browser bundles.
+ *
+ * Attention:
+ * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
+ * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)
+ * having issues tree-shaking these constants across package boundaries.
+ * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
+ * users to be able to shake away expressions that it guards.
+ */
+
+/**
+ * Figures out if we're building a browser bundle.
+ *
+ * @returns true if this is a browser bundle build.
+ */
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
+}
+
+/**
+ * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
+ * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
+ */
+
+/**
+ * Checks whether we're in the Node.js or Browser environment
+ *
+ * @returns Answer to given question
+ */
+function isNodeEnv() {
+  // explicitly check for browser bundles as those can be optimized statically
+  // by terser/rollup.
+  return (
+    !isBrowserBundle() &&
+    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+  );
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param request The module path to resolve
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function dynamicRequire(mod, request) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return mod.require(request);
+}
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+/** SyncPromise internal states */
+var States; (function (States) {
+  /** Pending */
+  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
+  /** Resolved / OK */
+  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
+  /** Rejected / Error */
+  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
+})(States || (States = {}));
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * An object that can return the current timestamp in seconds since the UNIX epoch.
+ */
+
+/**
+ * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+ *
+ * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+ * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+ * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+ */
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1000,
+};
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
   }
 
-  return obj;
+  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+  //
+  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+  // performance.now() gives a date arbitrarily in the past.
+  //
+  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+  // undefined.
+  //
+  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+  // interact with data coming out of performance entries.
+  //
+  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+  // observed skews that can be as long as days, weeks or months.
+  //
+  // See https://github.com/getsentry/sentry-javascript/issues/2590.
+  //
+  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+  // transactions of long-lived web pages.
+  const timeOrigin = Date.now() - performance.now();
+
+  return {
+    now: () => performance.now(),
+    timeOrigin,
+  };
 }
 
-function getGitBranchHead() {
+/**
+ * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+ * implement the API.
+ */
+function getNodePerformance() {
   try {
-    return child_process.execSync("git rev-parse HEAD").toString().trim();
-  } catch (e) {
-    // no git installed
+    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
+    return perfHooks.performance;
+  } catch (_) {
     return undefined;
   }
 }
 
-function getReleaseName(releaseName) {
-  if (releaseName) {
-    return releaseName;
-  } // Env var SENTRY_RELEASE takes presendace over other env vars listed below
-  // this is why we are looking for it before proceeding with others
+/**
+ * The Performance API implementation for the current platform, if available.
+ */
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+
+const timestampSource =
+  platformPerformance === undefined
+    ? dateTimestampSource
+    : {
+        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
+      };
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ */
+dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+ * availability of the Performance API.
+ *
+ * See `usingPerformanceAPI` to test whether the Performance API is used.
+ *
+ * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+ * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+ * skew can grow to arbitrary amounts like days, weeks or months.
+ * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ */
+timestampSource.nowSeconds.bind(timestampSource);
+
+/**
+ * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+ * performance API is available.
+ */
+(() => {
+  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
+  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
+  // data as reliable if they are within a reasonable threshold of the current time.
+
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
+  }
+
+  const threshold = 3600 * 1000;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+
+  // if timeOrigin isn't available set delta to threshold so it isn't used
+  const timeOriginDelta = performance.timeOrigin
+    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
+    : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+
+  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+  // Date API.
+  // eslint-disable-next-line deprecation/deprecation
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === 'number';
+  // if navigationStart isn't available set delta to threshold so it isn't used
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    // Use the more reliable time origin
+    if (timeOriginDelta <= navigationStartDelta) {
+      return performance.timeOrigin;
+    } else {
+      return navigationStart;
+    }
+  }
+  return dateNow;
+})();
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @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];
+}
 
+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, _ref3, _userOptions$customHe;
+
+  var options = {
+    // include is the only strictly required option
+    // (normalizeInclude needs all userOptions to access top-level include options)
+    include: normalizeInclude(userOptions),
+    // These options must be set b/c we need them for release injection.
+    // They can also be set as environment variables. Technically, they
+    // could be set in the config file but this would be too late for
+    // release injection because we only pass the config file path
+    // to the CLI
+    org: (_userOptions$org = userOptions.org) !== null && _userOptions$org !== void 0 ? _userOptions$org : process.env["SENTRY_ORG"],
+    project: (_userOptions$project = userOptions.project) !== null && _userOptions$project !== void 0 ? _userOptions$project : process.env["SENTRY_PROJECT"],
+    // Falling back to the empty string here b/c at a later point, we use
+    // Sentry CLI to determine a release if none was specified via options
+    // or env vars. In case we don't find one, we'll bail at that point.
+    release: (_ref = (_userOptions$release = userOptions.release) !== null && _userOptions$release !== void 0 ? _userOptions$release : process.env["SENTRY_RELEASE"]) !== null && _ref !== void 0 ? _ref : "",
+    // We technically don't need the URL for anything release-specific
+    // but we want to make sure that we're only sending Sentry data
+    // of SaaS customers. Hence we want to read it anyway.
+    url: (_ref2 = (_userOptions$url = userOptions.url) !== null && _userOptions$url !== void 0 ? _userOptions$url : process.env["SENTRY_URL"]) !== null && _ref2 !== void 0 ? _ref2 : SENTRY_SAAS_URL,
+    // Options with default values
+    finalize: (_userOptions$finalize = userOptions.finalize) !== null && _userOptions$finalize !== void 0 ? _userOptions$finalize : true,
+    cleanArtifacts: (_userOptions$cleanArt = userOptions.cleanArtifacts) !== null && _userOptions$cleanArt !== void 0 ? _userOptions$cleanArt : false,
+    dryRun: (_userOptions$dryRun = userOptions.dryRun) !== null && _userOptions$dryRun !== void 0 ? _userOptions$dryRun : false,
+    debug: (_userOptions$debug = userOptions.debug) !== null && _userOptions$debug !== void 0 ? _userOptions$debug : false,
+    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,
+    // 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
+    // the passed options are undefined.
+    authToken: userOptions.authToken,
+    // env var: `SENTRY_AUTH_TOKEN`
+    // CLI v1 (and the "old" webpack plugin) use `CUSTOM_HEADER`,
+    // but CLI v2 uses `SENTRY_HEADER` (which is also better aligned with other naming)
+    // In the spirit of maximum compatibility, we allow both here.
+    customHeader: (_ref3 = (_userOptions$customHe = userOptions.customHeader) !== null && _userOptions$customHe !== void 0 ? _userOptions$customHe : process.env["SENTRY_HEADER"]) !== null && _ref3 !== void 0 ? _ref3 : process.env["CUSTOM_HEADER"],
+    vcsRemote: userOptions.vcsRemote,
+    // env var: `SENTRY_VSC_REMOTE`
+    // Optional options
+    setCommits: userOptions.setCommits,
+    deploy: userOptions.deploy,
+    entries: normalizeEntries(userOptions.entries),
+    dist: userOptions.dist,
+    errorHandler: userOptions.errorHandler,
+    configFile: userOptions.configFile
+  }; // We only want to enable telemetry for SaaS users
+  // This is not the final check (we need to call Sentry CLI at a later point)
+  // but we can already at this point make a first decision.
+  // @see `turnOffTelemetryForSelfHostedSentry` (telemetry.ts) for the second check.
+
+  options.telemetry = options.telemetry && options.url === SENTRY_SAAS_URL;
+  return options;
+}
+/**
+ * Converts the user-facing `entries` option to the internal `entries` option
+ */
 
-  if (process.env["SENTRY_RELEASE"]) {
-    return process.env["SENTRY_RELEASE"];
+function normalizeEntries(userEntries) {
+  if (userEntries === undefined) {
+    return undefined;
+  } else if (typeof userEntries === "function") {
+    return userEntries;
+  } else {
+    return arrayify(userEntries);
   }
+}
+/**
+ * Converts the user-facing `include` option to the internal `include` option,
+ * resulting in an array of `InternalIncludeEntry` objects. This later on lets us
+ * work with only one type of include data structure instead of multiple.
+ *
+ * During the process, we hoist top-level include options (e.g. urlPrefix) into each
+ * object if they were not alrady specified in an `IncludeEntry`, making every object
+ * fully self-contained. This is also the reason why we pass the entire options
+ * object and not just `include`.
+ *
+ * @param userOptions the entire user-facing `options` object
+ *
+ * @return an array of `InternalIncludeEntry` objects.
+ */
+
+
+function normalizeInclude(userOptions) {
+  return arrayify(userOptions.include).map(function (includeItem) {
+    return typeof includeItem === "string" ? {
+      paths: [includeItem]
+    } : includeItem;
+  }).map(function (userIncludeEntry) {
+    return normalizeIncludeEntry(userOptions, userIncludeEntry);
+  });
+}
+/**
+ * Besides array-ifying the `ignore` option, this function hoists top level options into the items of the `include`
+ * option. This is to simplify the handling of of the `include` items later on.
+ */
+
+
+function normalizeIncludeEntry(userOptions, includeEntry) {
+  var _ref4, _includeEntry$ignore, _ref5, _includeEntry$ext, _includeEntry$ignoreF, _includeEntry$urlPref, _includeEntry$urlSuff, _includeEntry$stripPr, _ref6, _includeEntry$stripCo, _ref7, _includeEntry$sourceM, _ref8, _includeEntry$rewrite, _ref9, _includeEntry$validat;
+
+  var ignoreOption = (_ref4 = (_includeEntry$ignore = includeEntry.ignore) !== null && _includeEntry$ignore !== void 0 ? _includeEntry$ignore : userOptions.ignore) !== null && _ref4 !== void 0 ? _ref4 : ["node_modules"];
+  var ignore = Array.isArray(ignoreOption) ? ignoreOption : [ignoreOption]; // We're prefixing all entries in the `ext` option with a `.` (if it isn't already) to align with Node.js' `path.extname()`
 
-  var ENV_VARS = ["SOURCE_VERSION", // Heroku #1 https://devcenter.heroku.com/changelog-items/630
-  "HEROKU_SLUG_COMMIT", // Heroku #2: https://docs.sentry.io/product/integrations/deployment/heroku/#configure-releases
-  "CODEBUILD_RESOLVED_SOURCE_VERSION", // AWS CodeBuild: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
-  "CIRCLE_SHA1", // CircleCI: https://circleci.com/docs/2.0/env-vars/
-  "VERCEL_GIT_COMMIT_SHA" // Vercel docs: https://vercel.com/docs/concepts/projects/environment-variables#system-environment-variables
-  ];
-  var releaseFromEnvironmentVar = ENV_VARS.find(function (key) {
-    return Object.keys(process.env).includes(key);
+  var ext = (_ref5 = (_includeEntry$ext = includeEntry.ext) !== null && _includeEntry$ext !== void 0 ? _includeEntry$ext : userOptions.ext) !== null && _ref5 !== void 0 ? _ref5 : ["js", "map", "jsbundle", "bundle"];
+  var dotPrefixedExt = ext.map(function (extension) {
+    return ".".concat(extension.replace(/^\./, ""));
   });
+  return {
+    paths: includeEntry.paths,
+    ignore: ignore,
+    ignoreFile: (_includeEntry$ignoreF = includeEntry.ignoreFile) !== null && _includeEntry$ignoreF !== void 0 ? _includeEntry$ignoreF : userOptions.ignoreFile,
+    ext: dotPrefixedExt,
+    urlPrefix: (_includeEntry$urlPref = includeEntry.urlPrefix) !== null && _includeEntry$urlPref !== void 0 ? _includeEntry$urlPref : userOptions.urlPrefix,
+    urlSuffix: (_includeEntry$urlSuff = includeEntry.urlSuffix) !== null && _includeEntry$urlSuff !== void 0 ? _includeEntry$urlSuff : userOptions.urlSuffix,
+    stripPrefix: (_includeEntry$stripPr = includeEntry.stripPrefix) !== null && _includeEntry$stripPr !== void 0 ? _includeEntry$stripPr : userOptions.stripPrefix,
+    stripCommonPrefix: (_ref6 = (_includeEntry$stripCo = includeEntry.stripCommonPrefix) !== null && _includeEntry$stripCo !== void 0 ? _includeEntry$stripCo : userOptions.stripCommonPrefix) !== null && _ref6 !== void 0 ? _ref6 : false,
+    sourceMapReference: (_ref7 = (_includeEntry$sourceM = includeEntry.sourceMapReference) !== null && _includeEntry$sourceM !== void 0 ? _includeEntry$sourceM : userOptions.sourceMapReference) !== null && _ref7 !== void 0 ? _ref7 : true,
+    rewrite: (_ref8 = (_includeEntry$rewrite = includeEntry.rewrite) !== null && _includeEntry$rewrite !== void 0 ? _includeEntry$rewrite : userOptions.rewrite) !== null && _ref8 !== void 0 ? _ref8 : true,
+    validate: (_ref9 = (_includeEntry$validat = includeEntry.validate) !== null && _includeEntry$validat !== void 0 ? _includeEntry$validat : userOptions.validate) !== null && _ref9 !== void 0 ? _ref9 : false
+  };
+}
+/**
+ * Validates a few combinations of options that are not checked by Sentry CLI.
+ *
+ * For all other options, we can rely on Sentry CLI to validate them. In fact,
+ * we can't validate them in the plugin because Sentry CLI might pick up options from
+ * its config file.
+ *
+ * @param options the internal options
+ * @param logger the logger
+ *
+ * @returns `true` if the options are valid, `false` otherwise
+ */
+
 
-  if (releaseFromEnvironmentVar) {
-    return process.env[releaseFromEnvironmentVar];
+function validateOptions(options, logger) {
+  if (options.injectReleasesMap && !options.org) {
+    logger.error("The `injectReleasesMap` option was set but it is only supported when the `org` option is also specified.", "Please set the `org` option (you can also set the SENTRY_ORG environment variable) or disable the `injectReleasesMap` option.");
+    return false;
   }
 
-  var gitBranchHead = getGitBranchHead();
+  var setCommits = options.setCommits;
 
-  if (gitBranchHead) {
-    return gitBranchHead;
-  } else {
-    throw new Error("Could not return a release name");
+  if (setCommits) {
+    if (!setCommits.auto && !(setCommits.repo && setCommits.commit)) {
+      logger.error("The `setCommits` option was specified but is missing required properties.", "Please set either `auto` or both, `repo` and `commit`.");
+      return false;
+    }
+
+    if (setCommits.auto && setCommits.repo && setCommits) {
+      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.deploy && !options.deploy.env) {
+    logger.error("The `deploy` option was specified but is missing the required `env` property.", "Please set the `env` property.");
+    return false;
   }
+
+  return true;
 }
 
-function makeSentryClient(dsn, telemetryEnabled, org) {
+function makeSentryClient(dsn, telemetryEnabled) {
   var client = new NodeClient({
     dsn: dsn,
     enabled: telemetryEnabled,
     tracesSampleRate: telemetryEnabled ? 1.0 : 0.0,
     sampleRate: telemetryEnabled ? 1.0 : 0.0,
-    release: "0.0.1-alpha.0",
+    release: "0.1.0",
     integrations: [new Integrations.Http({
       tracing: true
     })],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: defaultStackParser,
-    transport: makeNodeTransport,
-    debug: true
+    transport: makeNodeTransport
   });
-  var hub = new Hub(client);
-  hub.configureScope(function (scope) {
-    if (org) {
-      scope.setTag("org", org);
-    }
-  }); //TODO: This call is problematic because as soon as we set our hub as the current hub
+  var hub = new Hub(client); //TODO: This call is problematic because as soon as we set our hub as the current hub
   //      we might interfere with other plugins that use Sentry. However, for now, we'll
   //      leave it in because without it, we can't get distributed traces (which are pretty nice)
   //      Let's keep it until someone complains about interference.
@@ -525,319 +985,135 @@ function addSpanToTransaction(ctx, op, description) {
   return span;
 }
 function captureMinimalError(error, hub) {
-  var isAxiosError = error instanceof AxiosError;
-  var sentryError = error instanceof Error ? {
-    name: "".concat(isAxiosError && error.status ? error.status : "", ": ").concat(error.name),
-    message: error.message,
-    stack: error.stack
-  } : {};
+  var sentryError;
+
+  if (error && _typeof(error) === "object") {
+    var e = error;
+    sentryError = {
+      name: e.name,
+      message: e.message,
+      stack: e.stack
+    };
+  } else {
+    sentryError = {
+      name: "Error",
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      message: "".concat(error)
+    };
+  }
+
   hub.captureException(sentryError);
 }
+function addPluginOptionTags(options, hub) {
+  var cleanArtifacts = options.cleanArtifacts,
+      finalize = options.finalize,
+      setCommits = options.setCommits,
+      injectReleasesMap = options.injectReleasesMap,
+      dryRun = options.dryRun,
+      errorHandler = options.errorHandler,
+      deploy = options.deploy,
+      include = options.include;
+  hub.setTag("include", include.length > 1 ? "multiple-entries" : "single-entry"); // Optional release pipeline steps
+
+  if (cleanArtifacts) {
+    hub.setTag("clean-artifacts", true);
+  }
 
-var API_PATH = "/api/0";
-var USER_AGENT = "sentry-bundler-plugin/".concat("0.0.1-alpha.0");
-
-var sentryApiAxiosInstance = function sentryApiAxiosInstance(_ref) {
-  var authToken = _ref.authToken,
-      customHeaders = _ref.customHeaders;
-  return axios.create({
-    headers: _objectSpread2(_objectSpread2({}, customHeaders), {}, {
-      "User-Agent": USER_AGENT,
-      Authorization: "Bearer ".concat(authToken)
-    })
-  });
-};
+  if (setCommits) {
+    hub.setTag("set-commits", setCommits.auto === true ? "auto" : "manual");
+  }
 
-function createRelease(_x) {
-  return _createRelease.apply(this, arguments);
-}
+  if (finalize) {
+    hub.setTag("finalize-release", true);
+  }
 
-function _createRelease() {
-  _createRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
-    var org, project, release, authToken, sentryUrl, sentryHub, customHeaders, requestUrl, releasePayload;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            org = _ref2.org, project = _ref2.project, release = _ref2.release, authToken = _ref2.authToken, sentryUrl = _ref2.sentryUrl, sentryHub = _ref2.sentryHub, customHeaders = _ref2.customHeaders;
-            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/organizations/").concat(org, "/releases/");
-            releasePayload = {
-              version: release,
-              projects: [project],
-              // we currently only support creating releases for a single project
-              dateStarted: new Date(),
-              dateReleased: new Date() //TODO: figure out if these dates are set correctly
+  if (deploy) {
+    hub.setTag("add-deploy", true);
+  } // Miscelaneous options
 
-            };
-            _context.prev = 3;
-            _context.next = 6;
-            return sentryApiAxiosInstance({
-              authToken: authToken,
-              customHeaders: customHeaders
-            }).post(requestUrl, releasePayload, {
-              headers: {
-                Authorization: "Bearer ".concat(authToken)
-              }
-            });
 
-          case 6:
-            _context.next = 12;
-            break;
+  if (dryRun) {
+    hub.setTag("dry-run", true);
+  }
 
-          case 8:
-            _context.prev = 8;
-            _context.t0 = _context["catch"](3);
-            captureMinimalError(_context.t0, sentryHub);
-            throw _context.t0;
+  if (injectReleasesMap) {
+    hub.setTag("inject-releases-map", true);
+  }
 
-          case 12:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee, null, [[3, 8]]);
-  }));
-  return _createRelease.apply(this, arguments);
-}
+  if (errorHandler) {
+    hub.setTag("error-handler", "custom");
+  }
 
-function deleteAllReleaseArtifacts(_x2) {
-  return _deleteAllReleaseArtifacts.apply(this, arguments);
+  hub.setTag("node", process.version);
 }
+/**
+ * Makes a call to SentryCLI to get the Sentry server URL the CLI uses.
+ *
+ * We need to check and decide to use telemetry based on the CLI's respone to this call
+ * because only at this time we checked a possibly existing .sentryclirc file. This file
+ * could point to another URL than the default URL.
+ */
 
-function _deleteAllReleaseArtifacts() {
-  _deleteAllReleaseArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref3) {
-    var org, project, release, authToken, sentryUrl, sentryHub, customHeaders, requestUrl;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            org = _ref3.org, project = _ref3.project, release = _ref3.release, authToken = _ref3.authToken, sentryUrl = _ref3.sentryUrl, sentryHub = _ref3.sentryHub, customHeaders = _ref3.customHeaders;
-            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/files/source-maps/?name=").concat(release);
-            _context2.prev = 2;
-            _context2.next = 5;
-            return sentryApiAxiosInstance({
-              authToken: authToken,
-              customHeaders: customHeaders
-            })["delete"](requestUrl, {
-              headers: {
-                Authorization: "Bearer ".concat(authToken)
-              }
-            });
-
-          case 5:
-            _context2.next = 11;
-            break;
-
-          case 7:
-            _context2.prev = 7;
-            _context2.t0 = _context2["catch"](2);
-            captureMinimalError(_context2.t0, sentryHub);
-            throw _context2.t0;
-
-          case 11:
-          case "end":
-            return _context2.stop();
-        }
-      }
-    }, _callee2, null, [[2, 7]]);
-  }));
-  return _deleteAllReleaseArtifacts.apply(this, arguments);
+function turnOffTelemetryForSelfHostedSentry(_x, _x2) {
+  return _turnOffTelemetryForSelfHostedSentry.apply(this, arguments);
 }
 
-function updateRelease(_x3) {
-  return _updateRelease.apply(this, arguments);
-}
+function _turnOffTelemetryForSelfHostedSentry() {
+  _turnOffTelemetryForSelfHostedSentry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(cli, hub) {
+    var _cliInfo$split$, _cliInfo$split$$repla;
 
-function _updateRelease() {
-  _updateRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
-    var release, org, authToken, sentryUrl, project, sentryHub, customHeaders, requestUrl, releasePayload;
-    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+    var cliInfo, url, client;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context.prev = _context.next) {
           case 0:
-            release = _ref4.release, org = _ref4.org, authToken = _ref4.authToken, sentryUrl = _ref4.sentryUrl, project = _ref4.project, sentryHub = _ref4.sentryHub, customHeaders = _ref4.customHeaders;
-            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/releases/").concat(release, "/");
-            releasePayload = {
-              dateReleased: new Date().toISOString()
-            };
-            _context3.prev = 3;
-            _context3.next = 6;
-            return sentryApiAxiosInstance({
-              authToken: authToken,
-              customHeaders: customHeaders
-            }).put(requestUrl, releasePayload, {
-              headers: {
-                Authorization: "Bearer ".concat(authToken)
-              }
-            });
-
-          case 6:
-            _context3.next = 12;
-            break;
-
-          case 8:
-            _context3.prev = 8;
-            _context3.t0 = _context3["catch"](3);
-            captureMinimalError(_context3.t0, sentryHub);
-            throw _context3.t0;
+            _context.next = 2;
+            return cli.execute(["info"], false);
 
-          case 12:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee3, null, [[3, 8]]);
-  }));
-  return _updateRelease.apply(this, arguments);
-}
+          case 2:
+            cliInfo = _context.sent;
+            url = cliInfo === null || cliInfo === void 0 ? void 0 : (_cliInfo$split$ = cliInfo.split(/(\r\n|\n|\r)/)[0]) === null || _cliInfo$split$ === void 0 ? void 0 : (_cliInfo$split$$repla = _cliInfo$split$.replace(/^Sentry Server: /, "")) === null || _cliInfo$split$$repla === void 0 ? void 0 : _cliInfo$split$$repla.trim();
 
-function uploadReleaseFile(_x4) {
-  return _uploadReleaseFile.apply(this, arguments);
-}
+            if (url !== SENTRY_SAAS_URL) {
+              client = hub.getClient();
 
-function _uploadReleaseFile() {
-  _uploadReleaseFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref5) {
-    var org, project, release, authToken, sentryUrl, filename, fileContent, sentryHub, customHeaders, requestUrl, form;
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            org = _ref5.org, project = _ref5.project, release = _ref5.release, authToken = _ref5.authToken, sentryUrl = _ref5.sentryUrl, filename = _ref5.filename, fileContent = _ref5.fileContent, sentryHub = _ref5.sentryHub, customHeaders = _ref5.customHeaders;
-            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/releases/").concat(release, "/files/");
-            form = new FormData();
-            form.append("name", filename);
-            form.append("file", Buffer.from(fileContent, "utf-8"), {
-              filename: filename
-            });
-            _context4.prev = 5;
-            _context4.next = 8;
-            return sentryApiAxiosInstance({
-              authToken: authToken,
-              customHeaders: customHeaders
-            }).post(requestUrl, form, {
-              headers: {
-                Authorization: "Bearer ".concat(authToken),
-                "Content-Type": "multipart/form-data"
+              if (client) {
+                client.getOptions().enabled = false;
+                client.getOptions().tracesSampleRate = 0;
+                client.getOptions().sampleRate = 0;
               }
-            });
-
-          case 8:
-            _context4.next = 14;
-            break;
-
-          case 10:
-            _context4.prev = 10;
-            _context4.t0 = _context4["catch"](5);
-            captureMinimalError(_context4.t0, sentryHub);
-            throw _context4.t0;
+            }
 
-          case 14:
+          case 5:
           case "end":
-            return _context4.stop();
+            return _context.stop();
         }
       }
-    }, _callee4, null, [[5, 10]]);
+    }, _callee);
   }));
-  return _uploadReleaseFile.apply(this, arguments);
-}
-
-function getFiles(path, allowedExtensions) {
-  var includedFiles = getAllIncludedFileNames(path, allowedExtensions, []);
-  return includedFiles.map(function (filename) {
-    var content = fs.readFileSync(filename, {
-      encoding: "utf-8"
-    });
-    return {
-      name: "~" + filename.replace(new RegExp("^".concat(path)), ""),
-      content: content
-    };
-  });
+  return _turnOffTelemetryForSelfHostedSentry.apply(this, arguments);
 }
 
-function getAllIncludedFileNames(dirPath, allowedExtensions, accFiles) {
-  var files = fs.readdirSync(dirPath);
-  files.map(function (file) {
-    return path.join(dirPath, "/", file);
-  }).forEach(function (file) {
-    if (fs.statSync(file).isDirectory()) {
-      accFiles = accFiles.concat(getAllIncludedFileNames(file, allowedExtensions, accFiles));
-    } else {
-      if (allowedExtensions.some(function (e) {
-        return file.endsWith(e);
-      })) {
-        accFiles.push(file);
-      }
-    }
-  });
-  return accFiles;
-}
-
-function createNewRelease(_x, _x2, _x3) {
+function createNewRelease(_x, _x2) {
   return _createNewRelease.apply(this, arguments);
 }
 
 function _createNewRelease() {
-  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(release, options, ctx) {
+  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, ctx) {
     var span;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.create_release"); // TODO: pull these checks out of here and simplify them
-
-            if (!(options.authToken === undefined)) {
-              _context.next = 6;
-              break;
-            }
-
-            ctx.logger.warn('Missing "authToken" option. Will not create release.');
-            return _context.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 6:
-            if (!(options.org === undefined)) {
-              _context.next = 11;
-              break;
-            }
+            span = addSpanToTransaction(ctx, "function.plugin.create_release");
+            _context.next = 3;
+            return ctx.cli.releases["new"](options.release);
 
-            ctx.logger.warn('Missing "org" option. Will not create release.');
-            return _context.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 11:
-            if (!(options.url === undefined)) {
-              _context.next = 16;
-              break;
-            }
-
-            ctx.logger.warn('Missing "url" option. Will not create release.');
-            return _context.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 16:
-            if (!(options.project === undefined)) {
-              _context.next = 19;
-              break;
-            }
-
-            ctx.logger.warn('Missing "project" option. Will not create release.');
-            return _context.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 19:
-            _context.next = 21;
-            return createRelease({
-              release: release,
-              authToken: options.authToken,
-              org: options.org,
-              project: options.project,
-              sentryUrl: options.url,
-              sentryHub: ctx.hub,
-              customHeaders: options.customHeaders
-            });
-
-          case 21:
+          case 3:
             ctx.logger.info("Successfully created release.");
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context.abrupt("return", Promise.resolve("nothing to do here"));
 
-          case 24:
+          case 5:
           case "end":
             return _context.stop();
         }
@@ -847,288 +1123,201 @@ function _createNewRelease() {
   return _createNewRelease.apply(this, arguments);
 }
 
-function uploadSourceMaps(_x4, _x5, _x6) {
-  return _uploadSourceMaps.apply(this, arguments);
+function cleanArtifacts(_x3, _x4) {
+  return _cleanArtifacts.apply(this, arguments);
 }
 
-function _uploadSourceMaps() {
-  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(release, options, ctx) {
-    var span, include, ext, org, project, authToken, url, fileExtensions, files;
+function _cleanArtifacts() {
+  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options, ctx) {
+    var span;
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.upload_sourcemaps"); // This is what Sentry CLI does:
-            //  TODO: 0. Preprocess source maps
-            //           - (Out of scope for now)
-            //           - For rewriting source maps see https://github.com/getsentry/rust-sourcemap/blob/master/src/types.rs#L763
-            //  TODO: 1. Creates a new release to make sure it exists
-            //           - can we assume that the release will exist b/c we don't give unplugin users the
-            //           option to skip this step?
-            //  TODO: 2. download already uploaded files and get their checksums
-            //  TODO: 3. identify new or changed files (by comparing checksums)
-            //  TODO: 4. upload new and changed files
-            //           - CLI asks API for chunk options https://github.com/getsentry/sentry-cli/blob/7b8466885d9cfd51aee6fdc041eca9f645026303/src/utils/file_upload.rs#L106-L112
-            //           - WTF?
-            //           - don't upload more than 20k files
-            //           - upload files concurrently
-            //           - 2 options: chunked upload (multiple files per chunk) or single file upload
-
-            include = options.include, ext = options.ext, org = options.org, project = options.project, authToken = options.authToken, url = options.url; // TODO: pull these checks out of here and simplify them
-
-            if (!(authToken === undefined)) {
-              _context2.next = 7;
-              break;
-            }
-
-            ctx.logger.warn('Missing "authToken" option. Will not create release.');
-            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 7:
-            if (!(org === undefined)) {
-              _context2.next = 12;
+            if (options.cleanArtifacts) {
+              _context2.next = 3;
               break;
             }
 
-            ctx.logger.warn('Missing "org" option. Will not create release.');
-            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 12:
-            if (!(url === undefined)) {
-              _context2.next = 17;
-              break;
-            }
+            logger.debug("Skipping artifact cleanup.");
+            return _context2.abrupt("return");
 
-            ctx.logger.warn('Missing "url" option. Will not create release.');
-            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
+          case 3:
+            span = addSpanToTransaction(ctx, "function.plugin.clean_artifacts");
+            _context2.next = 6;
+            return ctx.cli.releases.execute(["releases", "files", options.release, "delete", "--all"], true);
 
-          case 17:
-            if (!(project === undefined)) {
-              _context2.next = 20;
-              break;
-            }
+          case 6:
+            ctx.logger.info("Successfully cleaned previous artifacts.");
+            span === null || span === void 0 ? void 0 : span.finish();
 
-            ctx.logger.warn('Missing "project" option. Will not create release.');
-            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 20:
-            ctx.logger.info("Uploading Sourcemaps."); //TODO: Remove this once we have internal options. this property must always be present
-
-            fileExtensions = ext || [];
-            files = getFiles(include, fileExtensions);
-            ctx.logger.info("Found ".concat(files.length, " files to upload."));
-            return _context2.abrupt("return", Promise.all(files.map(function (file) {
-              return uploadReleaseFile({
-                org: org,
-                project: project,
-                release: release,
-                authToken: authToken,
-                sentryUrl: url,
-                filename: file.name,
-                fileContent: file.content,
-                sentryHub: ctx.hub,
-                customHeaders: options.customHeaders
-              });
-            })).then(function () {
-              ctx.logger.info("Successfully uploaded sourcemaps.");
-              span === null || span === void 0 ? void 0 : span.finish();
-              return "done";
-            }));
-
-          case 25:
+          case 8:
           case "end":
             return _context2.stop();
         }
       }
     }, _callee2);
   }));
-  return _uploadSourceMaps.apply(this, arguments);
+  return _cleanArtifacts.apply(this, arguments);
 }
 
-function finalizeRelease(_x7, _x8, _x9) {
-  return _finalizeRelease.apply(this, arguments);
+function uploadSourceMaps(_x5, _x6) {
+  return _uploadSourceMaps.apply(this, arguments);
 }
 
-function _finalizeRelease() {
-  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(release, options, ctx) {
-    var span, authToken, org, url, project;
+function _uploadSourceMaps() {
+  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options, ctx) {
+    var span;
     return _regeneratorRuntime().wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
-
-            if (!options.finalize) {
-              _context3.next = 9;
-              break;
-            }
-
-            authToken = options.authToken, org = options.org, url = options.url, project = options.project;
-
-            if (!(!authToken || !org || !url || !project)) {
-              _context3.next = 6;
-              break;
-            }
-
-            ctx.logger.warn("Missing required option. Will not clean existing artifacts.");
-            return _context3.abrupt("return", Promise.resolve("nothing to do here"));
+            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.
 
-          case 6:
-            _context3.next = 8;
-            return updateRelease({
-              authToken: authToken,
-              org: org,
-              release: release,
-              sentryUrl: url,
-              project: project,
-              sentryHub: ctx.hub,
-              customHeaders: options.customHeaders
+            _context3.next = 4;
+            return ctx.cli.releases.uploadSourceMaps(options.release, {
+              include: options.include
             });
 
-          case 8:
-            ctx.logger.info("Successfully finalized release.");
-
-          case 9:
+          case 4:
+            ctx.logger.info("Successfully uploaded Sourcemaps.");
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context3.abrupt("return", Promise.resolve("nothing to do here"));
 
-          case 11:
+          case 6:
           case "end":
             return _context3.stop();
         }
       }
     }, _callee3);
   }));
-  return _finalizeRelease.apply(this, arguments);
+  return _uploadSourceMaps.apply(this, arguments);
 }
 
-function cleanArtifacts(_x10, _x11, _x12) {
-  return _cleanArtifacts.apply(this, arguments);
-} // TODO: Stuff we worry about later:
+function setCommits(_x7, _x8) {
+  return _setCommits.apply(this, arguments);
+}
+
+function _setCommits() {
+  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx) {
+    var span, _options$setCommits, auto, repo, commit, previousCommit, ignoreMissing, ignoreEmpty;
 
-function _cleanArtifacts() {
-  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(release, options, ctx) {
-    var span;
     return _regeneratorRuntime().wrap(function _callee4$(_context4) {
       while (1) {
         switch (_context4.prev = _context4.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.clean_artifacts");
-
-            if (!options.cleanArtifacts) {
-              _context4.next = 23;
-              break;
-            }
-
-            if (!(options.authToken === undefined)) {
-              _context4.next = 7;
-              break;
-            }
-
-            ctx.logger.warn('Missing "authToken" option. Will not clean existing artifacts.');
-            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 7:
-            if (!(options.org === undefined)) {
-              _context4.next = 12;
-              break;
-            }
-
-            ctx.logger.warn('Missing "org" option. Will not clean existing artifacts.');
-            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 12:
-            if (!(options.url === undefined)) {
-              _context4.next = 17;
+            if (options.setCommits) {
+              _context4.next = 3;
               break;
             }
 
-            ctx.logger.warn('Missing "url" option. Will not clean existing artifacts.');
-            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 17:
-            if (!(options.project === undefined)) {
-              _context4.next = 20;
-              break;
-            }
+            logger.debug("Skipping setting commits to release.");
+            return _context4.abrupt("return");
 
-            ctx.logger.warn('Missing "project" option. Will not clean existing artifacts.');
-            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
-
-          case 20:
-            _context4.next = 22;
-            return deleteAllReleaseArtifacts({
-              authToken: options.authToken,
-              org: options.org,
-              release: release,
-              sentryUrl: options.url,
-              project: options.project,
-              sentryHub: ctx.hub,
-              customHeaders: options.customHeaders
+          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.next = 7;
+            return ctx.cli.releases.setCommits(options.release, {
+              commit: commit,
+              previousCommit: previousCommit,
+              repo: repo,
+              auto: auto,
+              ignoreMissing: ignoreMissing,
+              ignoreEmpty: ignoreEmpty
             });
 
-          case 22:
-            ctx.logger.info("Successfully cleaned previous artifacts.");
-
-          case 23:
+          case 7:
+            ctx.logger.info("Successfully set commits.");
             span === null || span === void 0 ? void 0 : span.finish();
-            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
 
-          case 25:
+          case 9:
           case "end":
             return _context4.stop();
         }
       }
     }, _callee4);
   }));
-  return _cleanArtifacts.apply(this, arguments);
+  return _setCommits.apply(this, arguments);
 }
 
-function setCommits(_x13) {
-  return _setCommits.apply(this, arguments);
+function finalizeRelease(_x9, _x10) {
+  return _finalizeRelease.apply(this, arguments);
 }
 
-function _setCommits() {
-  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(
-  /* version: string, */
-  ctx) {
+function _finalizeRelease() {
+  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx) {
     var span;
     return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.set_commits");
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context5.abrupt("return", Promise.resolve("Noop"));
+            if (options.finalize) {
+              _context5.next = 3;
+              break;
+            }
+
+            logger.debug("Skipping release finalization.");
+            return _context5.abrupt("return");
 
           case 3:
+            span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
+            _context5.next = 6;
+            return ctx.cli.releases.finalize(options.release);
+
+          case 6:
+            ctx.logger.info("Successfully finalized release.");
+            span === null || span === void 0 ? void 0 : span.finish();
+
+          case 8:
           case "end":
             return _context5.stop();
         }
       }
     }, _callee5);
   }));
-  return _setCommits.apply(this, arguments);
+  return _finalizeRelease.apply(this, arguments);
 }
 
-function addDeploy(_x14) {
+function addDeploy(_x11, _x12) {
   return _addDeploy.apply(this, arguments);
 }
 
 function _addDeploy() {
-  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(
-  /* version: string, */
-  ctx) {
-    var span;
+  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx) {
+    var span, _options$deploy, env, started, finished, time, name, url;
+
     return _regeneratorRuntime().wrap(function _callee6$(_context6) {
       while (1) {
         switch (_context6.prev = _context6.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.add_deploy");
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context6.abrupt("return", Promise.resolve("Noop"));
+            if (options.deploy) {
+              _context6.next = 3;
+              break;
+            }
+
+            logger.debug("Skipping adding deploy info to release.");
+            return _context6.abrupt("return");
 
           case 3:
+            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.next = 7;
+            return ctx.cli.releases.newDeploy(options.release, {
+              env: env,
+              started: started,
+              finished: finished,
+              time: time,
+              name: name,
+              url: url
+            });
+
+          case 7:
+            ctx.logger.info("Successfully added deploy.");
+            span === null || span === void 0 ? void 0 : span.finish();
+
+          case 9:
           case "end":
             return _context6.stop();
         }
@@ -1149,69 +1338,166 @@ function createLogger(options) {
 
   return {
     info: function info(message) {
-      if (!(options !== null && options !== void 0 && options.silent)) {
+      if (!options.silent) {
+        var _console;
+
+        for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          params[_key - 1] = arguments[_key];
+        }
+
         // eslint-disable-next-line no-console
-        console.log("".concat(options.prefix, " ").concat(message));
+        (_console = console).log.apply(_console, ["".concat(options.prefix, " Info: ").concat(message)].concat(params));
       }
 
       addBreadcrumb("info", message);
     },
     warn: function warn(message) {
-      if (!(options !== null && options !== void 0 && options.silent)) {
+      if (!options.silent) {
+        var _console2;
+
+        for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          params[_key2 - 1] = arguments[_key2];
+        }
+
         // eslint-disable-next-line no-console
-        console.log("".concat(options.prefix, " Warning! ").concat(message));
+        (_console2 = console).log.apply(_console2, ["".concat(options.prefix, " Warning: ").concat(message)].concat(params));
       }
 
       addBreadcrumb("warning", message);
     },
     error: function error(message) {
-      if (!(options !== null && options !== void 0 && options.silent)) {
+      if (!options.silent) {
+        var _console3;
+
+        for (var _len3 = arguments.length, params = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          params[_key3 - 1] = arguments[_key3];
+        }
+
         // eslint-disable-next-line no-console
-        console.log("".concat(options.prefix, " Error: ").concat(message));
+        (_console3 = console).log.apply(_console3, ["".concat(options.prefix, " Error: ").concat(message)].concat(params));
       }
 
       addBreadcrumb("error", message);
+    },
+    debug: function debug(message) {
+      if (!options.silent && options.debug) {
+        var _console4;
+
+        for (var _len4 = arguments.length, params = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+          params[_key4 - 1] = arguments[_key4];
+        }
+
+        // eslint-disable-next-line no-console
+        (_console4 = console).log.apply(_console4, ["".concat(options.prefix, " Debug: ").concat(message)].concat(params));
+      }
+
+      addBreadcrumb("debug", message);
+    }
+  };
+}
+
+/**
+ * Creates a new Sentry CLI instance.
+ *
+ * In case, users selected the `dryRun` options, this returns a stub
+ * that makes no-ops out of most CLI operations
+ */
+function getSentryCli(internalOptions, logger) {
+  var silent = internalOptions.silent,
+      org = internalOptions.org,
+      project = internalOptions.project,
+      authToken = internalOptions.authToken,
+      url = internalOptions.url,
+      vcsRemote = internalOptions.vcsRemote,
+      customHeader = internalOptions.customHeader,
+      dist = internalOptions.dist;
+  var cli = new SentryCli(internalOptions.configFile, {
+    url: url,
+    authToken: authToken,
+    org: org,
+    project: project,
+    vcsRemote: vcsRemote,
+    dist: dist,
+    silent: silent,
+    customHeader: customHeader
+  });
+
+  if (internalOptions.dryRun) {
+    logger.info("In DRY RUN Mode");
+    return getDryRunCLI(cli, logger);
+  }
+
+  return cli;
+}
+
+function getDryRunCLI(cli, logger) {
+  return {
+    releases: {
+      proposeVersion: function proposeVersion() {
+        return cli.releases.proposeVersion().then(function (version) {
+          logger.info("Proposed version:\n", version);
+          return version;
+        });
+      },
+      "new": function _new(release) {
+        logger.info("Creating new release:\n", release);
+        return Promise.resolve(release);
+      },
+      uploadSourceMaps: function uploadSourceMaps(release, config) {
+        logger.info("Calling upload-sourcemaps with:\n", config);
+        return Promise.resolve(release);
+      },
+      finalize: function finalize(release) {
+        logger.info("Finalizing release:\n", release);
+        return Promise.resolve(release);
+      },
+      setCommits: function setCommits(release, config) {
+        logger.info("Calling set-commits with:\n", config);
+        return Promise.resolve(release);
+      },
+      newDeploy: function newDeploy(release, config) {
+        logger.info("Calling deploy with:\n", config);
+        return Promise.resolve(release);
+      },
+      execute: function execute(args, live) {
+        logger.info("Executing", args, "live:", live);
+        return Promise.resolve("");
+      }
+    },
+    execute: function execute(args, live) {
+      logger.info("Executing", args, "live:", live);
+      return Promise.resolve("Executed");
     }
   };
 }
 
-var defaultOptions = {
-  //TODO: add default options here as we port over options from the webpack plugin
-  // validate: false
-  debug: false,
-  cleanArtifacts: false,
-  finalize: true,
-  url: "https://sentry.io",
-  ext: ["js", "map", "jsbundle", "bundle"],
-  telemetry: true
-}; // We prefix the polyfill id with \0 to tell other plugins not to try to load or transform it.
+// We prefix the polyfill id with \0 to tell other plugins not to try to load or transform it.
 // This hack is taken straight from https://rollupjs.org/guide/en/#resolveid.
 // This probably doesn't work for all bundlers but for rollup it does.
-
 var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
 /**
- * The sentry-unplugin concerns itself with two things:
+ * The sentry bundler plugin concerns itself with two things:
  * - Release injection
  * - Sourcemaps upload
  *
  * Release injection:
  *
- * Per default the sentry-unpugin will inject a global `SENTRY_RELEASE` variable into the entrypoint of all bundles. 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-unplugin
+ * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` variable into the entrypoint of all bundles.
+ * 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).
  *
  * The resulting output approximately looks like this:
  *
  * ```text
  *                               entrypoint1.js (user file)
- *  ┌───────────────────┐        ┌─────────────────────────────────────────────────┐
- *  │                   │        │  import { myFunction } from "./my-library.js";  │
- *  │  sentry-unplugin  │        │                                                 │
- *  │                   │        │  const myResult = myFunction();                 │
- *  └---------│---------┘        │  export { myResult };                           │
+ *  ┌─────────────────────────┐  ┌─────────────────────────────────────────────────┐
+ *  │                         │  │  import { myFunction } from "./my-library.js";  │
+ *  │  sentry-bundler-plugin  │  │                                                 │
+ *  │                         │  │  const myResult = myFunction();                 │
+ *  └---------│---------------   │  export { myResult };                           │
  *            │                  │                                                 │
- *            │      injects     │  // injected by sentry-unplugin                 │
+ *            │      injects     │  // injected by sentry plugin                   │
  *            ├───────────────────► import "sentry-release-injector"; ─────────────────────┐
  *            │                  └─────────────────────────────────────────────────┘       │
  *            │                                                                            │
@@ -1222,7 +1508,7 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
  *            │                  │    return "Hello world!";                       │       │
  *            │                  │  }                                              │       │
  *            │                  │                                                 │       │
- *            │      injects     │  // injected by sentry-unplugin                 │       │
+ *            │      injects     │  // injected by sentry plugin                   │       │
  *            └───────────────────► import "sentry-release-injector"; ─────────────────────┤
  *                               └─────────────────────────────────────────────────┘       │
  *                                                                                         │
@@ -1230,7 +1516,7 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
  *                               sentry-release-injector                                   │
  *                               ┌──────────────────────────────────┐                      │
  *                               │                                  │    is resolved       │
- *                               │  global.SENTRY_RELEASE = { ... } │    by unplugin       │
+ *                               │  global.SENTRY_RELEASE = { ... } │    by plugin         │
  *                               │  // + a little more logic        │<─────────────────────┘
  *                               │                                  │    (only once)
  *                               └──────────────────────────────────┘
@@ -1238,37 +1524,51 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
  *
  * Source maps upload:
  *
- * The sentry-unplugin will also take care of uploading source maps to Sentry. This is all done in the `buildEnd` hook.
- * TODO: elaborate a bit on how sourcemaps upload works
+ * The sentry bundler plugin will also take care of uploading source maps to Sentry. This is all done in the
+ * `writeBundle` hook. In this hook the sentry plugin will execute the release creation pipeline:
+ *
+ * 1. Create a new release
+ * 2. Delete already uploaded artifacts for this release (if `cleanArtifacts` is enabled)
+ * 3. Upload sourcemaps based on `include` and source-map-specific options
+ * 4. Associate a range of commits with the release (if `setCommits` is specified)
+ * 5. Finalize the release (unless `finalize` is disabled)
+ * 6. Add deploy information to the release (if `deploy` is specified)
+ *
+ * This release creation pipeline relies on Sentry CLI to execute the different steps.
  */
 
-var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
-  var options = _objectSpread2(_objectSpread2({}, defaultOptions), originalOptions); //TODO: We can get rid of this variable once we have internal plugin options
-
+var unplugin = createUnplugin(function (options, unpluginMetaContext) {
+  var internalOptions = normalizeUserOptions(options);
 
-  var telemetryEnabled = options.telemetry === true;
-
-  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", telemetryEnabled, options.org),
+  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", internalOptions.telemetry),
       sentryHub = _makeSentryClient.hub;
 
+  addPluginOptionTags(internalOptions, sentryHub);
   var logger = createLogger({
     hub: sentryHub,
     prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
-    silent: options.silent
+    silent: internalOptions.silent,
+    debug: internalOptions.debug
   });
 
-  if (telemetryEnabled) {
+  if (!validateOptions(internalOptions, logger)) {
+    handleError(new Error("Options were not set correctly. See output above for more details."), logger, internalOptions.errorHandler);
+  }
+
+  var cli = getSentryCli(internalOptions, logger);
+
+  if (internalOptions.telemetry) {
     logger.info("Sending error and performance telemetry data to Sentry.");
     logger.info("To disable telemetry, set `options.telemetry` to `false`.");
   }
 
   sentryHub.setTags({
-    organization: options.org,
-    project: options.project,
+    organization: internalOptions.org,
+    project: internalOptions.project,
     bundler: unpluginMetaContext.framework
   });
   sentryHub.setUser({
-    id: options.org
+    id: internalOptions.org
   }); // This is `nonEntrypointSet` instead of `entrypointSet` because this set is filled in the `resolveId` hook and there
   // we don't have guaranteed access to *absolute* paths of files if they're entrypoints. For non-entrypoints we're
   // guaranteed to have absolute paths - we're then using the paths in later hooks to make decisions about whether a
@@ -1286,15 +1586,50 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
      * Responsible for starting the plugin execution transaction and the release injection span
      */
     buildStart: function buildStart() {
-      transaction = sentryHub.startTransaction({
-        op: "function.plugin",
-        name: "Sentry Bundler Plugin execution"
-      });
-      releaseInjectionSpan = addSpanToTransaction({
-        hub: sentryHub,
-        parentSpan: transaction,
-        logger: logger
-      }, "function.plugin.inject_release", "Release injection");
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return turnOffTelemetryForSelfHostedSentry(cli, sentryHub);
+
+              case 2:
+                if (internalOptions.release) {
+                  _context.next = 6;
+                  break;
+                }
+
+                _context.next = 5;
+                return cli.releases.proposeVersion();
+
+              case 5:
+                internalOptions.release = _context.sent;
+
+              case 6:
+                // At this point, we either have determined a release or we have to bail
+                if (!internalOptions.release) {
+                  handleError(new Error("Unable to determine a release name. Make sure to set the `release` option or use an environment that supports auto-detection https://docs.sentry.io/cli/releases/#creating-releases`"), logger, internalOptions.errorHandler, sentryHub);
+                }
+
+                transaction = sentryHub.startTransaction({
+                  op: "function.plugin",
+                  name: "Sentry Bundler Plugin execution"
+                });
+                releaseInjectionSpan = addSpanToTransaction({
+                  hub: sentryHub,
+                  parentSpan: transaction,
+                  logger: logger,
+                  cli: cli
+                }, "function.plugin.inject_release", "Release injection");
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }))();
     },
 
     /**
@@ -1348,7 +1683,10 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
 
       if (id === RELEASE_INJECTOR_ID) {
         return generateGlobalInjectorCode({
-          release: getReleaseName(options.release)
+          release: internalOptions.release,
+          injectReleasesMap: internalOptions.injectReleasesMap,
+          org: internalOptions.org,
+          project: internalOptions.project
         });
       } else {
         return undefined;
@@ -1356,11 +1694,11 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
     },
 
     /**
-     * This hook determines whether we want to transform a module. In the unplugin we want to transform every entrypoint
+     * This hook determines whether we want to transform a module. In the sentry bundler plugin we want to transform every entrypoint
      * unless configured otherwise with the `entries` option.
      *
      * @param id Always the absolute (fully resolved) path to the module.
-     * @returns `true` or `false` depending on whether we want to transform the module. For the sentry-unplugin we only
+     * @returns `true` or `false` depending on whether we want to transform the module. For the sentry bundler plugin we only
      * want to transform the release injector file.
      */
     transformInclude: function transformInclude(id) {
@@ -1369,14 +1707,13 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
         level: "info"
       });
 
-      if (options.entries) {
+      if (internalOptions.entries) {
         // If there's an `entries` option transform (ie. inject the release varible) when the file path matches the option.
-        if (typeof options.entries === "function") {
-          return options.entries(id);
+        if (typeof internalOptions.entries === "function") {
+          return internalOptions.entries(id);
         }
 
-        var arrayifiedEntriesOption = Array.isArray(options.entries) ? options.entries : [options.entries];
-        return arrayifiedEntriesOption.some(function (entry) {
+        return internalOptions.entries.some(function (entry) {
           if (entry instanceof RegExp) {
             return entry.test(id);
           } else {
@@ -1426,63 +1763,50 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
      * Responsible for executing the sentry release creation pipeline (i.e. creating a release on
      * Sentry.io, uploading sourcemaps, associating commits and deploys and finalizing the release)
      */
-    buildEnd: function buildEnd() {
+    writeBundle: function writeBundle() {
       var _releaseInjectionSpan;
 
       (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
       var releasePipelineSpan = transaction && addSpanToTransaction({
         hub: sentryHub,
         parentSpan: transaction,
-        logger: logger
+        logger: logger,
+        cli: cli
       }, "function.plugin.release", "Release pipeline");
-      var release = getReleaseName(options.release);
       sentryHub.addBreadcrumb({
-        category: "buildEnd:start",
+        category: "writeBundle:start",
         level: "info"
-      }); //TODO:
-      //  1. validate options to see if we get a valid include property, release name, etc.
-      //  2. normalize the include property: Users can pass string | string [] | IncludeEntry[].
-      //     That's good for them but a hassle for us. Let's try to normalize this into one data type
-      //     (I vote IncludeEntry[]) and continue with that down the line
-
+      });
       var ctx = {
         hub: sentryHub,
         parentSpan: releasePipelineSpan,
-        logger: logger
+        logger: logger,
+        cli: cli
       };
-      createNewRelease(release, options, ctx).then(function () {
-        return cleanArtifacts(release, options, ctx);
+      createNewRelease(internalOptions, ctx).then(function () {
+        return cleanArtifacts(internalOptions, ctx);
+      }).then(function () {
+        return uploadSourceMaps(internalOptions, ctx);
       }).then(function () {
-        return uploadSourceMaps(release, options, ctx);
+        return setCommits(internalOptions, ctx);
       }).then(function () {
-        return setCommits(ctx);
-      }) // this is a noop for now
-      .then(function () {
-        return finalizeRelease(release, options, ctx);
+        return finalizeRelease(internalOptions, ctx);
+      }).then(function () {
+        return addDeploy(internalOptions, ctx);
       }).then(function () {
-        return addDeploy(ctx);
-      }) // this is a noop for now
-      .then(function () {
         var _transaction;
 
-        (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
+        return (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
       })["catch"](function (e) {
         var _transaction2;
 
-        captureMinimalError(e, sentryHub);
         (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
-        logger.error(e.message);
-
-        if (options.errorHandler) {
-          options.errorHandler(e);
-        } else {
-          throw e;
-        }
+        handleError(e, logger, internalOptions.errorHandler, sentryHub);
       })["finally"](function () {
         var _transaction3;
 
         sentryHub.addBreadcrumb({
-          category: "buildEnd:finish",
+          category: "writeBundle:finish",
           level: "info"
         });
         releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
@@ -1491,16 +1815,41 @@ var unplugin = createUnplugin(function (originalOptions, unpluginMetaContext) {
     }
   };
 });
+
+function handleError(error, logger, errorHandler, sentryHub) {
+  logger.error(error.message);
+
+  if (sentryHub) {
+    captureMinimalError(error, sentryHub);
+  }
+
+  if (errorHandler) {
+    errorHandler(error);
+  } else {
+    throw error;
+  }
+}
 /**
  * Generates code for the "sentry-release-injector" which is responsible for setting the global `SENTRY_RELEASE`
  * variable.
  */
 
+
 function generateGlobalInjectorCode(_ref2) {
-  var release = _ref2.release;
+  var release = _ref2.release,
+      injectReleasesMap = _ref2.injectReleasesMap,
+      org = _ref2.org,
+      project = _ref2.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.)
-  return "\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, "\"};");
+  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, "\"};");
+
+  if (injectReleasesMap && project) {
+    var key = org ? "".concat(project, "@").concat(org) : project;
+    code += "\n      _global.SENTRY_RELEASES=_global.SENTRY_RELEASES || {};\n      _global.SENTRY_RELEASES[\"".concat(key, "\"]={id:\"").concat(release, "\"};\n      ");
+  }
+
+  return code;
 } // eslint-disable-next-line @typescript-eslint/no-explicit-any