@storm-software/git-tools 2.131.127 → 2.131.128

package/bin/chunk-TOLGVHZM.cjs

@@ -0,0 +1,2116 @@
+'use strict';
+
+require('date-fns/formatDistanceToNow');
+var chalk = require('chalk');
+var z = require('zod/v4/mini');
+var defu = require('defu');
+var fs = require('fs');
+var c12 = require('c12');
+var path = require('path');
+var promises = require('fs/promises');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+var defu__default = /*#__PURE__*/_interopDefault(defu);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../config-tools/src/types.ts
+var LogLevel = {
+  SILENT: 0,
+  FATAL: 10,
+  ERROR: 20,
+  WARN: 30,
+  SUCCESS: 35,
+  INFO: 40,
+  PERFORMANCE: 50,
+  DEBUG: 60,
+  TRACE: 70,
+  ALL: 100
+};
+var LogLevelLabel = {
+  SILENT: "silent",
+  FATAL: "fatal",
+  ERROR: "error",
+  WARN: "warn",
+  SUCCESS: "success",
+  INFO: "info",
+  PERFORMANCE: "performance",
+  DEBUG: "debug",
+  TRACE: "trace",
+  ALL: "all"
+};
+
+// ../config-tools/src/utilities/colors.ts
+var DEFAULT_COLOR_CONFIG = {
+  light: {
+    background: "#fafafa",
+    foreground: "#1d1e22",
+    brand: "#1fb2a6",
+    alternate: "#db2777",
+    discovery: "#5C4EE5",
+    success: "#087f5b",
+    info: "#0550ae",
+    debug: "#8afafc",
+    warning: "#e3b341",
+    danger: "#D8314A",
+    fatal: "#51070f",
+    performance: "#13c302",
+    link: "#3fa6ff",
+    positive: "#22c55e",
+    negative: "#dc2626",
+    gradient: ["#1fb2a6", "#db2777", "#5C4EE5"]
+  },
+  dark: {
+    background: "#1e2124",
+    foreground: "#cbd5e1",
+    brand: "#2dd4bf",
+    alternate: "#db2777",
+    discovery: "#818cf8",
+    success: "#10b981",
+    info: "#58a6ff",
+    debug: "#8afafc",
+    warning: "#f3d371",
+    danger: "#D8314A",
+    fatal: "#a40e26",
+    performance: "#80fd74",
+    link: "#3fa6ff",
+    positive: "#22c55e",
+    negative: "#dc2626",
+    gradient: ["#1fb2a6", "#db2777", "#818cf8"]
+  }
+};
+function getColors(config) {
+  if (!config?.colors || typeof config.colors !== "object" || !config.colors["dark"] && (!config.colors["base"] || typeof config.colors !== "object" || !config.colors["base"]?.["dark"])) {
+    return DEFAULT_COLOR_CONFIG;
+  }
+  if (config.colors["base"]) {
+    if (typeof config.colors["base"]["dark"] === "object") {
+      return config.colors["base"]["dark"];
+    } else if (config.colors["base"]["dark"] === "string") {
+      return config.colors["base"];
+    }
+  }
+  if (typeof config.colors["dark"] === "object") {
+    return config.colors["dark"];
+  }
+  return config.colors ?? DEFAULT_COLOR_CONFIG;
+}
+function getColor(key, config) {
+  const colors = getColors(config);
+  const result = (typeof colors["dark"] === "object" ? colors["dark"][key] : colors[key]) || DEFAULT_COLOR_CONFIG["dark"][key] || DEFAULT_COLOR_CONFIG[key];
+  if (result) {
+    return result;
+  }
+  return getColor("brand", config);
+}
+var chalkDefault = {
+  hex: (_) => (message) => message,
+  bgHex: (_) => ({
+    whiteBright: (message) => message,
+    white: (message) => message
+  }),
+  white: (message) => message,
+  whiteBright: (message) => message,
+  gray: (message) => message,
+  bold: {
+    hex: (_) => (message) => message,
+    bgHex: (_) => ({
+      whiteBright: (message) => message,
+      white: (message) => message
+    }),
+    whiteBright: (message) => message,
+    white: (message) => message
+  },
+  dim: {
+    hex: (_) => (message) => message,
+    gray: (message) => message
+  }
+};
+var getChalk = () => {
+  let _chalk = chalk__default.default;
+  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright || !_chalk?.white) {
+    _chalk = chalkDefault;
+  }
+  return _chalk;
+};
+
+// ../config-tools/src/logger/is-unicode-supported.ts
+function isUnicodeSupported() {
+  if (process.platform !== "win32") {
+    return process.env.TERM !== "linux";
+  }
+  return Boolean(process.env.WT_SESSION) || // Windows Terminal
+  Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+  process.env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
+  process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERM === "rxvt-unicode" || process.env.TERM === "rxvt-unicode-256color" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// ../config-tools/src/logger/console-icons.ts
+var useIcon = (c, fallback) => isUnicodeSupported() ? c : fallback;
+var CONSOLE_ICONS = {
+  [LogLevelLabel.ERROR]: useIcon("\u2718", "\xD7"),
+  [LogLevelLabel.FATAL]: useIcon("\u{1F571}", "\xD7"),
+  [LogLevelLabel.WARN]: useIcon("\u26A0", "\u203C"),
+  [LogLevelLabel.INFO]: useIcon("\u2139", "i"),
+  [LogLevelLabel.PERFORMANCE]: useIcon("\u23F1", "\u23F1"),
+  [LogLevelLabel.SUCCESS]: useIcon("\u2714", "\u221A"),
+  [LogLevelLabel.DEBUG]: useIcon("\u{1F6E0}", "D"),
+  [LogLevelLabel.TRACE]: useIcon("\u2699", "T"),
+  [LogLevelLabel.ALL]: useIcon("\u2709", "\u2192")
+};
+
+// ../config-tools/src/logger/format-timestamp.ts
+var formatTimestamp = (fullDateTime = false, date = /* @__PURE__ */ new Date()) => {
+  return fullDateTime ? `${date.toLocaleDateString()} ${date.toLocaleTimeString()}` : `${date.toLocaleTimeString()}`;
+};
+
+// ../config-tools/src/logger/get-log-level.ts
+var getLogLevel = (label) => {
+  switch (label) {
+    case "all":
+      return LogLevel.ALL;
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "performance":
+      return LogLevel.PERFORMANCE;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    case "fatal":
+      return LogLevel.FATAL;
+    case "silent":
+      return LogLevel.SILENT;
+    default:
+      return LogLevel.INFO;
+  }
+};
+var getLogLevelLabel = (logLevel = LogLevel.INFO) => {
+  if (logLevel >= LogLevel.ALL) {
+    return LogLevelLabel.ALL;
+  }
+  if (logLevel >= LogLevel.TRACE) {
+    return LogLevelLabel.TRACE;
+  }
+  if (logLevel >= LogLevel.DEBUG) {
+    return LogLevelLabel.DEBUG;
+  }
+  if (logLevel >= LogLevel.PERFORMANCE) {
+    return LogLevelLabel.PERFORMANCE;
+  }
+  if (logLevel >= LogLevel.INFO) {
+    return LogLevelLabel.INFO;
+  }
+  if (logLevel >= LogLevel.WARN) {
+    return LogLevelLabel.WARN;
+  }
+  if (logLevel >= LogLevel.ERROR) {
+    return LogLevelLabel.ERROR;
+  }
+  if (logLevel >= LogLevel.FATAL) {
+    return LogLevelLabel.FATAL;
+  }
+  if (logLevel <= LogLevel.SILENT) {
+    return LogLevelLabel.SILENT;
+  }
+  return LogLevelLabel.INFO;
+};
+var isVerbose = (label = LogLevelLabel.SILENT) => {
+  const logLevel = typeof label === "string" ? getLogLevel(label) : label;
+  return logLevel >= LogLevel.DEBUG;
+};
+
+// ../config-tools/src/logger/console.ts
+var getLogFn = (logLevel = LogLevel.INFO, config = {}, options = {}) => {
+  const {
+    chalk: _chalk = getChalk(),
+    fullDateTime = false,
+    hideDateTime = false
+  } = options;
+  const colors = !config.colors?.dark && !config.colors?.["base"] && !config.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config.colors?.dark && typeof config.colors.dark === "string" ? config.colors : config.colors?.["base"]?.dark && typeof config.colors["base"].dark === "string" ? config.colors["base"].dark : config.colors?.["base"] ? config.colors?.["base"] : DEFAULT_COLOR_CONFIG;
+  const configLogLevel = config.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
+  if (logLevel > getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT || getLogLevel(configLogLevel) <= LogLevel.SILENT) {
+    return (_) => {
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel) {
+    return (message) => {
+      console.error(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.fatal ?? DEFAULT_COLOR_CONFIG.dark.fatal)(
+          `[${CONSOLE_ICONS[LogLevelLabel.FATAL]} Fatal] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel) {
+    return (message) => {
+      console.error(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.danger ?? DEFAULT_COLOR_CONFIG.dark.danger)(
+          `[${CONSOLE_ICONS[LogLevelLabel.ERROR]} Error] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel) {
+    return (message) => {
+      console.warn(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.warning ?? DEFAULT_COLOR_CONFIG.dark.warning)(
+          `[${CONSOLE_ICONS[LogLevelLabel.WARN]} Warn] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel) {
+    return (message) => {
+      console.info(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.success ?? DEFAULT_COLOR_CONFIG.dark.success)(
+          `[${CONSOLE_ICONS[LogLevelLabel.SUCCESS]} Success] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel) {
+    return (message) => {
+      console.info(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.info ?? DEFAULT_COLOR_CONFIG.dark.info)(
+          `[${CONSOLE_ICONS[LogLevelLabel.INFO]} Info] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.PERFORMANCE >= logLevel) {
+    return (message) => {
+      console.debug(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.performance ?? DEFAULT_COLOR_CONFIG.dark.performance)(
+          `[${CONSOLE_ICONS[LogLevelLabel.PERFORMANCE]} Performance] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.DEBUG >= logLevel) {
+    return (message) => {
+      console.debug(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.debug ?? DEFAULT_COLOR_CONFIG.dark.debug)(
+          `[${CONSOLE_ICONS[LogLevelLabel.DEBUG]} Debug] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel) {
+    return (message) => {
+      console.debug(
+        `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex("#bbbbbb")(
+          `[${CONSOLE_ICONS[LogLevelLabel.TRACE]} Trace] `
+        )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  return (message) => {
+    console.log(
+      `
+${hideDateTime ? "" : `${_chalk.gray(formatTimestamp(fullDateTime))} `}${_chalk.hex(colors.brand ?? DEFAULT_COLOR_CONFIG.dark.brand)(
+        `[${CONSOLE_ICONS[LogLevelLabel.ALL]} System] `
+      )}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+    );
+  };
+};
+var writeFatal = (message, config) => getLogFn(LogLevel.FATAL, config)(message);
+var writeError = (message, config) => getLogFn(LogLevel.ERROR, config)(message);
+var writeWarning = (message, config) => getLogFn(LogLevel.WARN, config)(message);
+var writeInfo = (message, config) => getLogFn(LogLevel.INFO, config)(message);
+var writeSuccess = (message, config) => getLogFn(LogLevel.SUCCESS, config)(message);
+var writeDebug = (message, config) => getLogFn(LogLevel.DEBUG, config)(message);
+var writeTrace = (message, config) => getLogFn(LogLevel.TRACE, config)(message);
+var MAX_DEPTH = 10;
+var formatLogMessage = (message, options = {}, depth2 = 0) => {
+  if (depth2 > MAX_DEPTH) {
+    return "<max depth>";
+  }
+  const prefix = options.prefix ?? "";
+  const skip = options.skip ?? [];
+  const sort = options.sort ?? true;
+  return typeof message === "undefined" || message === null ? "<empty>" : typeof message === "string" ? !message ? "<empty string>" : message : Array.isArray(message) ? `
+${message.sort(
+    sort ? (a, b) => !a && !b ? 0 : !a ? 1 : !b ? -1 : String(a).localeCompare(String(b)) : void 0
+  ).map(
+    (item, index) => ` ${prefix}> #${index} = ${formatLogMessage(
+      item,
+      { prefix: `${prefix}--`, skip, sort },
+      depth2 + 1
+    )}`
+  ).join("\n")}` : typeof message === "object" && message ? `
+${Object.keys(message).filter(
+    (key) => typeof key !== "string" || !skip.map((k) => k.toLowerCase().trim()).includes(key.toLowerCase().trim())
+  ).sort(
+    sort ? (a, b) => !a && !b ? 0 : !a ? 1 : !b ? -1 : String(a).localeCompare(String(b)) : void 0
+  ).map(
+    (key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" && message[key] ? Object.keys(message[key]).filter(
+      (key2) => typeof key2 !== "string" || !skip.map((k) => k.toLowerCase().trim()).includes(key2.toLowerCase().trim())
+    ).length === 0 ? "{}" : formatLogMessage(
+      message[key],
+      { prefix: `${prefix}--`, skip, sort },
+      depth2 + 1
+    ) : message[key]}`
+  ).join("\n")}` : String(message);
+};
+var _isFunction = (value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
+  } catch {
+    return false;
+  }
+};
+var brandIcon = (config = {}, _chalk = getChalk()) => _chalk.hex(getColor("brand", config))("\u{1F5F2}");
+
+// ../config-tools/src/utilities/process-handler.ts
+var exitWithError = (config) => {
+  writeFatal("Exiting script with an error status...", config);
+  process.exit(1);
+};
+var exitWithSuccess = (config) => {
+  writeSuccess("Script completed successfully. Exiting...", config);
+  process.exit(0);
+};
+var handleProcess = (config) => {
+  writeTrace(
+    `Using the following arguments to process the script: ${process.argv.join(", ")}`,
+    config
+  );
+  process.on("unhandledRejection", (error) => {
+    writeError(
+      `An Unhandled Rejection occurred while running the program: ${error && typeof error === "object" && "message" in error && error?.message ? error.message : typeof error === "string" ? error : "Unknown error"} 
+Stacktrace: ${error && typeof error === "object" && "stack" in error && error?.stack ? error.stack : ""}`,
+      config
+    );
+    exitWithError(config);
+  });
+  process.on("uncaughtException", (error) => {
+    writeError(
+      `An Uncaught Exception occurred while running the program: ${error && typeof error === "object" && "message" in error && error?.message ? error.message : typeof error === "string" ? error : "Unknown error"} 
+Stacktrace: ${error && typeof error === "object" && "stack" in error && error?.stack ? error.stack : ""}`,
+      config
+    );
+    exitWithError(config);
+  });
+  process.on("SIGTERM", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+  process.on("SIGINT", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+  process.on("SIGHUP", (signal) => {
+    writeError(`The program terminated with signal code: ${signal}`, config);
+    exitWithError(config);
+  });
+};
+
+// ../config/src/constants.ts
+var STORM_DEFAULT_DOCS = "https://docs.stormsoftware.com";
+var STORM_DEFAULT_HOMEPAGE = "https://stormsoftware.com";
+var STORM_DEFAULT_LICENSING = "https://stormsoftware.com/license";
+var STORM_DEFAULT_LICENSE = "Apache-2.0";
+var STORM_DEFAULT_RELEASE_BANNER = "https://public.storm-cdn.com/storm-software/media/banner-1280x320.gif";
+var STORM_DEFAULT_ERROR_CODES_FILE = "tools/errors/codes.json";
+var STORM_DEFAULT_BANNER_ALT = "The workspace's banner image";
+var COLOR_KEYS = [
+  "dark",
+  "light",
+  "base",
+  "brand",
+  "alternate",
+  "accent",
+  "link",
+  "success",
+  "discovery",
+  "info",
+  "warning",
+  "danger",
+  "fatal",
+  "performance",
+  "positive",
+  "negative"
+];
+
+// ../config/src/schema.ts
+var schemaRegistry = z__namespace.registry();
+var colorSchema = z__namespace.string().check(
+  z__namespace.length(7),
+  z__namespace.toLowerCase(),
+  z__namespace.regex(/^#([0-9a-f]{3}){1,2}$/i),
+  z__namespace.trim()
+);
+schemaRegistry.add(colorSchema, {
+  description: "A base schema for describing the format of colors"
+});
+var darkColorSchema = z__namespace._default(colorSchema, "#1e2124");
+schemaRegistry.add(darkColorSchema, {
+  description: "The dark background color of the workspace"
+});
+var lightColorSchema = z__namespace._default(colorSchema, "#cbd5e1");
+schemaRegistry.add(lightColorSchema, {
+  description: "The light background color of the workspace"
+});
+var brandColorSchema = z__namespace._default(colorSchema, "#1fb2a6");
+schemaRegistry.add(brandColorSchema, {
+  description: "The primary brand specific color of the workspace"
+});
+var alternateColorSchema = z__namespace.optional(colorSchema);
+schemaRegistry.add(alternateColorSchema, {
+  description: "The alternate brand specific color of the workspace"
+});
+var accentColorSchema = z__namespace.optional(colorSchema);
+schemaRegistry.add(accentColorSchema, {
+  description: "The secondary brand specific color of the workspace"
+});
+var linkColorSchema = z__namespace._default(colorSchema, "#3fa6ff");
+schemaRegistry.add(linkColorSchema, {
+  description: "The color used to display hyperlink text"
+});
+var discoveryColorSchema = z__namespace._default(colorSchema, "#818cf8");
+schemaRegistry.add(discoveryColorSchema, {
+  description: "The second brand specific color of the workspace"
+});
+var successColorSchema = z__namespace._default(colorSchema, "#45b27e");
+schemaRegistry.add(successColorSchema, {
+  description: "The success color of the workspace"
+});
+var infoColorSchema = z__namespace._default(colorSchema, "#38bdf8");
+schemaRegistry.add(infoColorSchema, {
+  description: "The informational color of the workspace"
+});
+var debugColorSchema = z__namespace._default(colorSchema, "#8afafc");
+schemaRegistry.add(debugColorSchema, {
+  description: "The debug color of the workspace"
+});
+var warningColorSchema = z__namespace._default(colorSchema, "#f3d371");
+schemaRegistry.add(warningColorSchema, {
+  description: "The warning color of the workspace"
+});
+var dangerColorSchema = z__namespace._default(colorSchema, "#d8314a");
+schemaRegistry.add(dangerColorSchema, {
+  description: "The danger color of the workspace"
+});
+var fatalColorSchema = z__namespace.optional(colorSchema);
+schemaRegistry.add(fatalColorSchema, {
+  description: "The fatal color of the workspace"
+});
+var performanceColorSchema = z__namespace._default(colorSchema, "#80fd74");
+schemaRegistry.add(performanceColorSchema, {
+  description: "The performance color of the workspace"
+});
+var positiveColorSchema = z__namespace._default(colorSchema, "#4ade80");
+schemaRegistry.add(positiveColorSchema, {
+  description: "The positive number color of the workspace"
+});
+var negativeColorSchema = z__namespace._default(colorSchema, "#ef4444");
+schemaRegistry.add(negativeColorSchema, {
+  description: "The negative number color of the workspace"
+});
+var gradientStopsSchema = z__namespace.optional(z__namespace.array(colorSchema));
+schemaRegistry.add(gradientStopsSchema, {
+  description: "The color stops for the base gradient color pattern used in the workspace"
+});
+var darkColorsSchema = z__namespace.object({
+  foreground: lightColorSchema,
+  background: darkColorSchema,
+  brand: brandColorSchema,
+  alternate: alternateColorSchema,
+  accent: accentColorSchema,
+  link: linkColorSchema,
+  discovery: discoveryColorSchema,
+  success: successColorSchema,
+  info: infoColorSchema,
+  debug: debugColorSchema,
+  warning: warningColorSchema,
+  danger: dangerColorSchema,
+  fatal: fatalColorSchema,
+  performance: performanceColorSchema,
+  positive: positiveColorSchema,
+  negative: negativeColorSchema,
+  gradient: gradientStopsSchema
+});
+var lightColorsSchema = z__namespace.object({
+  foreground: darkColorSchema,
+  background: lightColorSchema,
+  brand: brandColorSchema,
+  alternate: alternateColorSchema,
+  accent: accentColorSchema,
+  link: linkColorSchema,
+  discovery: discoveryColorSchema,
+  success: successColorSchema,
+  info: infoColorSchema,
+  debug: debugColorSchema,
+  warning: warningColorSchema,
+  danger: dangerColorSchema,
+  fatal: fatalColorSchema,
+  performance: performanceColorSchema,
+  positive: positiveColorSchema,
+  negative: negativeColorSchema,
+  gradient: gradientStopsSchema
+});
+var multiColorsSchema = z__namespace.object({
+  dark: darkColorsSchema,
+  light: lightColorsSchema
+});
+var singleColorsSchema = z__namespace.object({
+  dark: darkColorSchema,
+  light: lightColorSchema,
+  brand: brandColorSchema,
+  alternate: alternateColorSchema,
+  accent: accentColorSchema,
+  link: linkColorSchema,
+  discovery: discoveryColorSchema,
+  success: successColorSchema,
+  info: infoColorSchema,
+  debug: debugColorSchema,
+  warning: warningColorSchema,
+  danger: dangerColorSchema,
+  fatal: fatalColorSchema,
+  performance: performanceColorSchema,
+  positive: positiveColorSchema,
+  negative: negativeColorSchema,
+  gradient: gradientStopsSchema
+});
+var registryUrlConfigSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(registryUrlConfigSchema, {
+  description: "A remote registry URL used to publish distributable packages"
+});
+var registrySchema = z__namespace._default(
+  z__namespace.object({
+    github: registryUrlConfigSchema,
+    npm: registryUrlConfigSchema,
+    cargo: registryUrlConfigSchema,
+    cyclone: registryUrlConfigSchema,
+    container: registryUrlConfigSchema
+  }),
+  {}
+);
+schemaRegistry.add(registrySchema, {
+  description: "A list of remote registry URLs used by Storm Software"
+});
+var colorsSchema = z__namespace.union([singleColorsSchema, multiColorsSchema]);
+schemaRegistry.add(colorsSchema, {
+  description: "Colors used for various workspace elements"
+});
+var themeColorsSchema = z__namespace.record(
+  z__namespace.union([z__namespace.union([z__namespace.literal("base"), z__namespace.string()]), z__namespace.string()]),
+  colorsSchema
+);
+schemaRegistry.add(themeColorsSchema, {
+  description: "Storm theme config values used for styling various package elements"
+});
+var extendsSchema = z__namespace.optional(
+  z__namespace.union([z__namespace.string().check(z__namespace.trim()), z__namespace.array(z__namespace.string().check(z__namespace.trim()))])
+);
+schemaRegistry.add(extendsSchema, {
+  description: "The path to a base config file to use as a configuration preset file. Documentation can be found at https://github.com/unjs/c12#extending-configuration."
+});
+var workspaceBotNameSchema = z__namespace.string().check(z__namespace.trim());
+schemaRegistry.add(workspaceBotNameSchema, {
+  description: "The workspace bot user's name (this is the bot that will be used to perform various tasks)"
+});
+var workspaceBotEmailSchema = z__namespace.string().check(z__namespace.trim());
+schemaRegistry.add(workspaceBotEmailSchema, {
+  description: "The email of the workspace bot"
+});
+var workspaceBotSchema = z__namespace.object({
+  name: workspaceBotNameSchema,
+  email: workspaceBotEmailSchema
+});
+schemaRegistry.add(workspaceBotSchema, {
+  description: "The workspace's bot user's config used to automated various operations tasks"
+});
+var workspaceReleaseBannerUrlSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.url())
+);
+schemaRegistry.add(workspaceReleaseBannerUrlSchema, {
+  description: "A URL to a banner image used to display the workspace's release"
+});
+var workspaceReleaseBannerAltSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim()),
+  STORM_DEFAULT_BANNER_ALT
+);
+schemaRegistry.add(workspaceReleaseBannerAltSchema, {
+  description: "The alt text for the workspace's release banner image"
+});
+var workspaceReleaseBannerSchema = z__namespace.object({
+  url: workspaceReleaseBannerUrlSchema,
+  alt: workspaceReleaseBannerAltSchema
+});
+schemaRegistry.add(workspaceReleaseBannerSchema, {
+  description: "The workspace's banner image used during the release process"
+});
+var workspaceReleaseHeaderSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceReleaseHeaderSchema, {
+  description: "A header message appended to the start of the workspace's release notes"
+});
+var workspaceReleaseFooterSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceReleaseFooterSchema, {
+  description: "A footer message appended to the end of the workspace's release notes"
+});
+var workspaceReleaseSchema = z__namespace.object({
+  banner: z__namespace.union([
+    workspaceReleaseBannerSchema,
+    z__namespace.string().check(z__namespace.trim(), z__namespace.url())
+  ]),
+  header: workspaceReleaseHeaderSchema,
+  footer: workspaceReleaseFooterSchema
+});
+schemaRegistry.add(workspaceReleaseSchema, {
+  description: "The workspace's release config used during the release process"
+});
+var workspaceSocialsTwitterSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsTwitterSchema, {
+  description: "A Twitter/X account associated with the organization/project"
+});
+var workspaceSocialsDiscordSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsDiscordSchema, {
+  description: "A Discord account associated with the organization/project"
+});
+var workspaceSocialsTelegramSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsTelegramSchema, {
+  description: "A Telegram account associated with the organization/project"
+});
+var workspaceSocialsSlackSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsSlackSchema, {
+  description: "A Slack account associated with the organization/project"
+});
+var workspaceSocialsMediumSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsMediumSchema, {
+  description: "A Medium account associated with the organization/project"
+});
+var workspaceSocialsGithubSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceSocialsGithubSchema, {
+  description: "A GitHub account associated with the organization/project"
+});
+var workspaceSocialsSchema = z__namespace.object({
+  twitter: workspaceSocialsTwitterSchema,
+  discord: workspaceSocialsDiscordSchema,
+  telegram: workspaceSocialsTelegramSchema,
+  slack: workspaceSocialsSlackSchema,
+  medium: workspaceSocialsMediumSchema,
+  github: workspaceSocialsGithubSchema
+});
+schemaRegistry.add(workspaceSocialsSchema, {
+  description: "The workspace's account config used to store various social media links"
+});
+var workspaceDirectoryCacheSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceDirectoryCacheSchema, {
+  description: "The directory used to store the environment's cached file data"
+});
+var workspaceDirectoryDataSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceDirectoryDataSchema, {
+  description: "The directory used to store the environment's data files"
+});
+var workspaceDirectoryConfigSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceDirectoryConfigSchema, {
+  description: "The directory used to store the environment's configuration files"
+});
+var workspaceDirectoryTempSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceDirectoryTempSchema, {
+  description: "The directory used to store the environment's temp files"
+});
+var workspaceDirectoryLogSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(workspaceDirectoryLogSchema, {
+  description: "The directory used to store the environment's log files"
+});
+var workspaceDirectoryBuildSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim()),
+  "dist"
+);
+schemaRegistry.add(workspaceDirectoryBuildSchema, {
+  description: "The directory used to store the workspace's distributable files after a build (relative to the workspace root)"
+});
+var workspaceDirectorySchema = z__namespace.object({
+  cache: workspaceDirectoryCacheSchema,
+  data: workspaceDirectoryDataSchema,
+  config: workspaceDirectoryConfigSchema,
+  temp: workspaceDirectoryTempSchema,
+  log: workspaceDirectoryLogSchema,
+  build: workspaceDirectoryBuildSchema
+});
+schemaRegistry.add(workspaceDirectorySchema, {
+  description: "Various directories used by the workspace to store data, cache, and configuration files"
+});
+var variantSchema = z__namespace._default(
+  z__namespace.enum(["minimal", "monorepo"]),
+  "monorepo"
+);
+schemaRegistry.add(variantSchema, {
+  description: "The variant of the workspace. This can be used to enable or disable certain features or configurations."
+});
+var errorCodesFileSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim()),
+  STORM_DEFAULT_ERROR_CODES_FILE
+);
+schemaRegistry.add(errorCodesFileSchema, {
+  description: "The path to the workspace's error codes JSON file"
+});
+var errorUrlSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(errorUrlSchema, {
+  description: "A URL to a page that looks up the workspace's error messages given a specific error code"
+});
+var errorSchema = z__namespace.object({
+  codesFile: errorCodesFileSchema,
+  url: errorUrlSchema
+});
+schemaRegistry.add(errorSchema, {
+  description: "The workspace's error config used when creating error details during a system error"
+});
+var organizationNameSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase())
+);
+schemaRegistry.add(organizationNameSchema, {
+  description: "The name of the organization"
+});
+var organizationDescriptionSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim())
+);
+schemaRegistry.add(organizationDescriptionSchema, {
+  description: "A description of the organization"
+});
+var organizationLogoSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(organizationLogoSchema, {
+  description: "A URL to the organization's logo image"
+});
+var organizationIconSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(organizationIconSchema, {
+  description: "A URL to the organization's icon image"
+});
+var organizationUrlSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(organizationUrlSchema, {
+  description: "A URL to a page that provides more information about the organization"
+});
+var organizationSchema = z__namespace.object({
+  name: organizationNameSchema,
+  description: organizationDescriptionSchema,
+  logo: organizationLogoSchema,
+  icon: organizationIconSchema,
+  url: organizationUrlSchema
+});
+schemaRegistry.add(organizationSchema, {
+  description: "The workspace's organization details"
+});
+var schemaNameSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase()),
+  "https://public.storm-cdn.com/schemas/storm-workspace.schema.json"
+);
+schemaRegistry.add(schemaNameSchema, {
+  description: "The URL or file path to the JSON schema file that describes the Storm configuration file"
+});
+var nameSchema = z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase());
+schemaRegistry.add(nameSchema, {
+  description: "The name of the workspace/project/service/package/scope using this configuration"
+});
+var namespaceSchema = z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase());
+schemaRegistry.add(namespaceSchema, {
+  description: "The namespace of the workspace/project/service/package/scope using this configuration"
+});
+var orgSchema = z__namespace.union([
+  organizationSchema,
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase())
+]);
+schemaRegistry.add(orgSchema, {
+  description: "The organization of the workspace. This can be a string or an object containing the organization's details"
+});
+var repositorySchema = z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase());
+schemaRegistry.add(repositorySchema, {
+  description: "The repo URL of the workspace (i.e. the GitHub repository URL)"
+});
+var licenseSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim()),
+  "Apache-2.0"
+);
+schemaRegistry.add(licenseSchema, {
+  description: "The license type of the package"
+});
+var homepageSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(homepageSchema, {
+  description: "The homepage of the workspace"
+});
+var docsSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(docsSchema, {
+  description: "The documentation site for the workspace"
+});
+var portalSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(portalSchema, {
+  description: "The development portal site for the workspace"
+});
+var licensingSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(licensingSchema, {
+  description: "The licensing site for the workspace"
+});
+var contactSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(contactSchema, {
+  description: "The contact site for the workspace"
+});
+var supportSchema = z__namespace.optional(z__namespace.url());
+schemaRegistry.add(supportSchema, {
+  description: "The support site for the workspace. If not provided, this is defaulted to the `contact` config value"
+});
+var branchSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase()),
+  "main"
+);
+schemaRegistry.add(branchSchema, {
+  description: "The branch of the workspace"
+});
+var preidSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase())
+);
+schemaRegistry.add(preidSchema, {
+  description: "A tag specifying the version pre-release identifier"
+});
+var ownerSchema = z__namespace.optional(
+  z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase())
+);
+schemaRegistry.add(ownerSchema, {
+  description: "The owner of the package"
+});
+var modeSchema = z__namespace._default(
+  z__namespace.enum(["development", "test", "production"]).check(z__namespace.trim(), z__namespace.toLowerCase()),
+  "production"
+);
+schemaRegistry.add(modeSchema, {
+  description: "The current runtime environment mode for the package"
+});
+var workspaceRootSchema = z__namespace.string().check(z__namespace.trim(), z__namespace.toLowerCase());
+schemaRegistry.add(workspaceRootSchema, {
+  description: "The root directory of the workspace"
+});
+var skipCacheSchema = z__namespace._default(z__namespace.boolean(), false);
+schemaRegistry.add(skipCacheSchema, {
+  description: "Should all known types of workspace caching be skipped?"
+});
+var packageManagerSchema = z__namespace._default(
+  z__namespace.enum(["npm", "yarn", "pnpm", "bun"]),
+  "npm"
+);
+schemaRegistry.add(packageManagerSchema, {
+  description: "The JavaScript/TypeScript package manager used by the repository"
+});
+var timezoneSchema = z__namespace._default(
+  z__namespace.string().check(z__namespace.trim()),
+  "America/New_York"
+);
+schemaRegistry.add(timezoneSchema, {
+  description: "The default timezone of the workspace"
+});
+var localeSchema = z__namespace._default(z__namespace.string().check(z__namespace.trim()), "en-US");
+schemaRegistry.add(localeSchema, {
+  description: "The default locale of the workspace"
+});
+var logLevelSchema = z__namespace._default(
+  z__namespace.enum([
+    "silent",
+    "fatal",
+    "error",
+    "warn",
+    "success",
+    "info",
+    "performance",
+    "debug",
+    "trace",
+    "all"
+  ]),
+  "info"
+);
+schemaRegistry.add(logLevelSchema, {
+  description: "The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."
+});
+var skipConfigLoggingSchema = z__namespace._default(z__namespace.boolean(), true);
+schemaRegistry.add(skipConfigLoggingSchema, {
+  description: "Should the logging of the current Storm Workspace configuration be skipped?"
+});
+var configFileSchema = z__namespace._default(
+  z__namespace.nullable(z__namespace.string().check(z__namespace.trim())),
+  null
+);
+schemaRegistry.add(configFileSchema, {
+  description: "The filepath of the Storm config. When this field is null, no config file was found in the current workspace."
+});
+var extensionsSchema = z__namespace._default(z__namespace.record(z__namespace.string(), z__namespace.any()), {});
+schemaRegistry.add(extensionsSchema, {
+  description: "Configuration of each used extension"
+});
+var workspaceConfigSchema = z__namespace.object({
+  $schema: schemaNameSchema,
+  extends: extendsSchema,
+  name: nameSchema,
+  variant: variantSchema,
+  namespace: namespaceSchema,
+  organization: orgSchema,
+  repository: repositorySchema,
+  license: licenseSchema,
+  homepage: homepageSchema,
+  docs: docsSchema,
+  portal: portalSchema,
+  licensing: licensingSchema,
+  contact: contactSchema,
+  support: supportSchema,
+  branch: branchSchema,
+  preid: preidSchema,
+  owner: ownerSchema,
+  bot: workspaceBotSchema,
+  release: workspaceReleaseSchema,
+  socials: workspaceSocialsSchema,
+  error: errorSchema,
+  mode: modeSchema,
+  workspaceRoot: workspaceRootSchema,
+  skipCache: skipCacheSchema,
+  directories: workspaceDirectorySchema,
+  packageManager: packageManagerSchema,
+  timezone: timezoneSchema,
+  locale: localeSchema,
+  logLevel: logLevelSchema,
+  skipConfigLogging: skipConfigLoggingSchema,
+  registry: registrySchema,
+  configFile: configFileSchema,
+  colors: z__namespace.union([colorsSchema, themeColorsSchema]),
+  extensions: extensionsSchema
+});
+schemaRegistry.add(extensionsSchema, {
+  description: "Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo."
+});
+
+// ../config-tools/src/utilities/correct-paths.ts
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var correctPaths = function(path) {
+  if (!path || path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path?.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+var joinPaths = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return correctPaths(path);
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
+  const _startPath = startPath ?? process.cwd();
+  if (endDirectoryNames.some(
+    (endDirName) => fs.existsSync(path.join(_startPath, endDirName))
+  )) {
+    return _startPath;
+  }
+  if (endFileNames.some((endFileName) => fs.existsSync(path.join(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = path.join(_startPath, "..");
+    return findFolderUp(parent, endFileNames, endDirectoryNames);
+  }
+  return void 0;
+}
+
+// ../config-tools/src/utilities/find-workspace-root.ts
+var rootFiles = [
+  "storm-workspace.json",
+  "storm-workspace.yaml",
+  "storm-workspace.yml",
+  "storm-workspace.js",
+  "storm-workspace.ts",
+  ".storm-workspace.json",
+  ".storm-workspace.yaml",
+  ".storm-workspace.yml",
+  ".storm-workspace.js",
+  ".storm-workspace.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb",
+  "bun.lock",
+  "bunfig.toml"
+];
+var rootDirectories = [
+  ".storm-workspace",
+  ".nx",
+  ".git",
+  ".github",
+  ".vscode",
+  ".verdaccio"
+];
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return correctPaths(
+      process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH
+    );
+  }
+  return correctPaths(
+    findFolderUp(
+      pathInsideMonorepo ?? process.cwd(),
+      rootFiles,
+      rootDirectories
+    )
+  );
+}
+function findWorkspaceRoot(pathInsideMonorepo) {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(
+      `Cannot find workspace root upwards from known path. Files search list includes: 
+${rootFiles.join(
+        "\n"
+      )}
+Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
+    );
+  }
+  return result;
+}
+async function getPackageJsonConfig(root) {
+  let license = STORM_DEFAULT_LICENSE;
+  let homepage = void 0;
+  let support = void 0;
+  let name = void 0;
+  let namespace = void 0;
+  let repository = void 0;
+  const workspaceRoot = findWorkspaceRoot(root);
+  if (fs.existsSync(path.join(workspaceRoot, "package.json"))) {
+    const file = await promises.readFile(
+      joinPaths(workspaceRoot, "package.json"),
+      "utf8"
+    );
+    if (file) {
+      const packageJson = JSON.parse(file);
+      if (packageJson.name) {
+        name = packageJson.name;
+      }
+      if (packageJson.namespace) {
+        namespace = packageJson.namespace;
+      }
+      if (packageJson.repository) {
+        if (typeof packageJson.repository === "string") {
+          repository = packageJson.repository;
+        } else if (packageJson.repository.url) {
+          repository = packageJson.repository.url;
+        }
+      }
+      if (packageJson.license) {
+        license = packageJson.license;
+      }
+      if (packageJson.homepage) {
+        homepage = packageJson.homepage;
+      }
+      if (packageJson.bugs) {
+        if (typeof packageJson.bugs === "string") {
+          support = packageJson.bugs;
+        } else if (packageJson.bugs.url) {
+          support = packageJson.bugs.url;
+        }
+      }
+    }
+  }
+  return {
+    workspaceRoot,
+    name,
+    namespace,
+    repository,
+    license,
+    homepage,
+    support
+  };
+}
+function applyDefaultConfig(config) {
+  if (!config.support && config.contact) {
+    config.support = config.contact;
+  }
+  if (!config.contact && config.support) {
+    config.contact = config.support;
+  }
+  if (config.homepage) {
+    if (!config.docs) {
+      config.docs = `${config.homepage}/docs`;
+    }
+    if (!config.license) {
+      config.license = `${config.homepage}/license`;
+    }
+    if (!config.support) {
+      config.support = `${config.homepage}/support`;
+    }
+    if (!config.contact) {
+      config.contact = `${config.homepage}/contact`;
+    }
+    if (!config.error?.codesFile || !config?.error?.url) {
+      config.error ??= { codesFile: STORM_DEFAULT_ERROR_CODES_FILE };
+      if (config.homepage) {
+        config.error.url ??= `${config.homepage}/errors`;
+      }
+    }
+  }
+  return config;
+}
+
+// ../config-tools/src/config-file/get-config-file.ts
+var getConfigFileByName = async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || findWorkspaceRoot(filePath);
+  const configs = await Promise.all([
+    c12.loadConfig({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: fileName?.toUpperCase(),
+      jitiOptions: {
+        debug: false,
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
+          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
+          "jiti"
+        )
+      },
+      ...options
+    }),
+    c12.loadConfig({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: fileName?.toUpperCase(),
+      jitiOptions: {
+        debug: false,
+        fsCache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(
+          process.env.STORM_CACHE_DIR || "node_modules/.cache/storm",
+          "jiti"
+        )
+      },
+      configFile: fileName,
+      ...options
+    })
+  ]);
+  return defu__default.default(configs[0] ?? {}, configs[1] ?? {});
+};
+var getConfigFile = async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
+  const result = await getConfigFileByName("storm-workspace", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0 && !config.skipConfigLogging) {
+    writeTrace(
+      `Found Storm configuration file "${configFile.includes(`${workspacePath}/`) ? configFile.replace(`${workspacePath}/`, "") : configFile}" at "${workspacePath}"`,
+      {
+        logLevel: "all"
+      }
+    );
+  }
+  if (additionalFileNames && additionalFileNames.length > 0) {
+    const results = await Promise.all(
+      additionalFileNames.map(
+        (fileName) => getConfigFileByName(fileName, workspacePath)
+      )
+    );
+    for (const result2 of results) {
+      if (result2?.config && result2?.configFile && Object.keys(result2.config).length > 0) {
+        if (!config.skipConfigLogging && !result2.config.skipConfigLogging) {
+          writeTrace(
+            `Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`,
+            {
+              logLevel: "all"
+            }
+          );
+        }
+        config = defu__default.default(result2.config ?? {}, config ?? {});
+      }
+    }
+  }
+  if (!config || Object.keys(config).length === 0) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+};
+var getConfigEnv = () => {
+  const prefix = "STORM_";
+  let config = {
+    extends: process.env[`${prefix}EXTENDS`] || void 0,
+    name: process.env[`${prefix}NAME`] || void 0,
+    variant: process.env[`${prefix}VARIANT`] || void 0,
+    namespace: process.env[`${prefix}NAMESPACE`] || void 0,
+    owner: process.env[`${prefix}OWNER`] || void 0,
+    bot: {
+      name: process.env[`${prefix}BOT_NAME`] || void 0,
+      email: process.env[`${prefix}BOT_EMAIL`] || void 0
+    },
+    release: {
+      banner: {
+        url: process.env[`${prefix}RELEASE_BANNER_URL`] || void 0,
+        alt: process.env[`${prefix}RELEASE_BANNER_ALT`] || void 0
+      },
+      header: process.env[`${prefix}RELEASE_HEADER`] || void 0,
+      footer: process.env[`${prefix}RELEASE_FOOTER`] || void 0
+    },
+    error: {
+      codesFile: process.env[`${prefix}ERROR_CODES_FILE`] || void 0,
+      url: process.env[`${prefix}ERROR_URL`] || void 0
+    },
+    socials: {
+      twitter: process.env[`${prefix}SOCIAL_TWITTER`] || void 0,
+      discord: process.env[`${prefix}SOCIAL_DISCORD`] || void 0,
+      telegram: process.env[`${prefix}SOCIAL_TELEGRAM`] || void 0,
+      slack: process.env[`${prefix}SOCIAL_SLACK`] || void 0,
+      medium: process.env[`${prefix}SOCIAL_MEDIUM`] || void 0,
+      github: process.env[`${prefix}SOCIAL_GITHUB`] || void 0
+    },
+    organization: process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`] ? process.env[`${prefix}ORG_DESCRIPTION`] || process.env[`${prefix}ORGANIZATION_DESCRIPTION`] || process.env[`${prefix}ORG_URL`] || process.env[`${prefix}ORGANIZATION_URL`] || process.env[`${prefix}ORG_LOGO`] || process.env[`${prefix}ORGANIZATION_LOGO`] ? {
+      name: process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`],
+      description: process.env[`${prefix}ORG_DESCRIPTION`] || process.env[`${prefix}ORGANIZATION_DESCRIPTION`] || void 0,
+      url: process.env[`${prefix}ORG_URL`] || process.env[`${prefix}ORGANIZATION_URL`] || void 0,
+      logo: process.env[`${prefix}ORG_LOGO`] || process.env[`${prefix}ORGANIZATION_LOGO`] || void 0,
+      icon: process.env[`${prefix}ORG_ICON`] || process.env[`${prefix}ORGANIZATION_ICON`] || void 0
+    } : process.env[`${prefix}ORG`] || process.env[`${prefix}ORGANIZATION`] || process.env[`${prefix}ORG_NAME`] || process.env[`${prefix}ORGANIZATION_NAME`] : void 0,
+    packageManager: process.env[`${prefix}PACKAGE_MANAGER`] || void 0,
+    license: process.env[`${prefix}LICENSE`] || void 0,
+    homepage: process.env[`${prefix}HOMEPAGE`] || void 0,
+    docs: process.env[`${prefix}DOCS`] || void 0,
+    portal: process.env[`${prefix}PORTAL`] || void 0,
+    licensing: process.env[`${prefix}LICENSING`] || void 0,
+    contact: process.env[`${prefix}CONTACT`] || void 0,
+    support: process.env[`${prefix}SUPPORT`] || void 0,
+    timezone: process.env[`${prefix}TIMEZONE`] || process.env.TZ || void 0,
+    locale: process.env[`${prefix}LOCALE`] || process.env.LOCALE || void 0,
+    configFile: process.env[`${prefix}WORKSPACE_CONFIG_FILE`] ? correctPaths(process.env[`${prefix}WORKSPACE_CONFIG_FILE`]) : void 0,
+    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`] ? correctPaths(process.env[`${prefix}WORKSPACE_ROOT`]) : void 0,
+    directories: {
+      cache: process.env[`${prefix}CACHE_DIR`] ? correctPaths(process.env[`${prefix}CACHE_DIR`]) : process.env[`${prefix}CACHE_DIRECTORY`] ? correctPaths(process.env[`${prefix}CACHE_DIRECTORY`]) : void 0,
+      data: process.env[`${prefix}DATA_DIR`] ? correctPaths(process.env[`${prefix}DATA_DIR`]) : process.env[`${prefix}DATA_DIRECTORY`] ? correctPaths(process.env[`${prefix}DATA_DIRECTORY`]) : void 0,
+      config: process.env[`${prefix}CONFIG_DIR`] ? correctPaths(process.env[`${prefix}CONFIG_DIR`]) : process.env[`${prefix}CONFIG_DIRECTORY`] ? correctPaths(process.env[`${prefix}CONFIG_DIRECTORY`]) : void 0,
+      temp: process.env[`${prefix}TEMP_DIR`] ? correctPaths(process.env[`${prefix}TEMP_DIR`]) : process.env[`${prefix}TEMP_DIRECTORY`] ? correctPaths(process.env[`${prefix}TEMP_DIRECTORY`]) : void 0,
+      log: process.env[`${prefix}LOG_DIR`] ? correctPaths(process.env[`${prefix}LOG_DIR`]) : process.env[`${prefix}LOG_DIRECTORY`] ? correctPaths(process.env[`${prefix}LOG_DIRECTORY`]) : void 0,
+      build: process.env[`${prefix}BUILD_DIR`] ? correctPaths(process.env[`${prefix}BUILD_DIR`]) : process.env[`${prefix}BUILD_DIRECTORY`] ? correctPaths(process.env[`${prefix}BUILD_DIRECTORY`]) : void 0
+    },
+    skipCache: process.env[`${prefix}SKIP_CACHE`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CACHE`]) : void 0,
+    mode: (process.env[`${prefix}MODE`] ?? process.env.NODE_ENV ?? process.env.ENVIRONMENT) || void 0,
+    // ci:
+    //   process.env[`${prefix}CI`] !== undefined
+    //     ? Boolean(
+    //         process.env[`${prefix}CI`] ??
+    //           process.env.CI ??
+    //           process.env.CONTINUOUS_INTEGRATION
+    //       )
+    //     : undefined,
+    repository: process.env[`${prefix}REPOSITORY`] || void 0,
+    branch: process.env[`${prefix}BRANCH`] || void 0,
+    preid: process.env[`${prefix}PRE_ID`] || void 0,
+    registry: {
+      github: process.env[`${prefix}REGISTRY_GITHUB`] || void 0,
+      npm: process.env[`${prefix}REGISTRY_NPM`] || void 0,
+      cargo: process.env[`${prefix}REGISTRY_CARGO`] || void 0,
+      cyclone: process.env[`${prefix}REGISTRY_CYCLONE`] || void 0,
+      container: process.env[`${prefix}REGISTRY_CONTAINER`] || void 0
+    },
+    logLevel: process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== void 0 ? process.env[`${prefix}LOG_LEVEL`] && Number.isSafeInteger(
+      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
+    ) ? getLogLevelLabel(
+      Number.parseInt(process.env[`${prefix}LOG_LEVEL`])
+    ) : process.env[`${prefix}LOG_LEVEL`] : void 0,
+    skipConfigLogging: process.env[`${prefix}SKIP_CONFIG_LOGGING`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CONFIG_LOGGING`]) : void 0
+  };
+  const themeNames = Object.keys(process.env).filter(
+    (envKey) => envKey.startsWith(`${prefix}COLOR_`) && COLOR_KEYS.every(
+      (colorKey) => !envKey.startsWith(`${prefix}COLOR_LIGHT_${colorKey}`) && !envKey.startsWith(`${prefix}COLOR_DARK_${colorKey}`)
+    )
+  );
+  config.colors = themeNames.length > 0 ? themeNames.reduce(
+    (ret, themeName) => {
+      ret[themeName] = getThemeColorsEnv(prefix, themeName);
+      return ret;
+    },
+    {}
+  ) : getThemeColorsEnv(prefix);
+  if (config.docs === STORM_DEFAULT_DOCS) {
+    if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
+      config.docs = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/docs`;
+    } else {
+      config.docs = `${config.homepage}/docs`;
+    }
+  }
+  if (config.licensing === STORM_DEFAULT_LICENSING) {
+    if (config.homepage === STORM_DEFAULT_HOMEPAGE) {
+      config.licensing = `${STORM_DEFAULT_HOMEPAGE}/projects/${config.name}/licensing`;
+    } else {
+      config.licensing = `${config.homepage}/docs`;
+    }
+  }
+  const serializedConfig = process.env[`${prefix}WORKSPACE_CONFIG`];
+  if (serializedConfig) {
+    const parsed = JSON.parse(serializedConfig);
+    config = {
+      ...config,
+      ...parsed,
+      colors: { ...config.colors, ...parsed.colors },
+      extensions: { ...config.extensions, ...parsed.extensions }
+    };
+  }
+  return config;
+};
+var getThemeColorsEnv = (prefix, theme) => {
+  const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
+  return process.env[`${prefix}${themeName}LIGHT_BRAND`] || process.env[`${prefix}${themeName}DARK_BRAND`] ? getMultiThemeColorsEnv(prefix + themeName) : getSingleThemeColorsEnv(prefix + themeName);
+};
+var getSingleThemeColorsEnv = (prefix) => {
+  const gradient = [];
+  if (process.env[`${prefix}GRADIENT_START`] && process.env[`${prefix}GRADIENT_END`]) {
+    gradient.push(
+      process.env[`${prefix}GRADIENT_START`],
+      process.env[`${prefix}GRADIENT_END`]
+    );
+  } else if (process.env[`${prefix}GRADIENT_0`] || process.env[`${prefix}GRADIENT_1`]) {
+    let index = process.env[`${prefix}GRADIENT_0`] ? 0 : 1;
+    while (process.env[`${prefix}GRADIENT_${index}`]) {
+      gradient.push(process.env[`${prefix}GRADIENT_${index}`]);
+      index++;
+    }
+  }
+  return {
+    dark: process.env[`${prefix}DARK`],
+    light: process.env[`${prefix}LIGHT`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    discovery: process.env[`${prefix}DISCOVERY`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    debug: process.env[`${prefix}DEBUG`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    performance: process.env[`${prefix}PERFORMANCE`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`],
+    gradient
+  };
+};
+var getMultiThemeColorsEnv = (prefix) => {
+  return {
+    light: getBaseThemeColorsEnv(`${prefix}_LIGHT_`),
+    dark: getBaseThemeColorsEnv(`${prefix}_DARK_`)
+  };
+};
+var getBaseThemeColorsEnv = (prefix) => {
+  const gradient = [];
+  if (process.env[`${prefix}GRADIENT_START`] && process.env[`${prefix}GRADIENT_END`]) {
+    gradient.push(
+      process.env[`${prefix}GRADIENT_START`],
+      process.env[`${prefix}GRADIENT_END`]
+    );
+  } else if (process.env[`${prefix}GRADIENT_0`] || process.env[`${prefix}GRADIENT_1`]) {
+    let index = process.env[`${prefix}GRADIENT_0`] ? 0 : 1;
+    while (process.env[`${prefix}GRADIENT_${index}`]) {
+      gradient.push(process.env[`${prefix}GRADIENT_${index}`]);
+      index++;
+    }
+  }
+  return {
+    foreground: process.env[`${prefix}FOREGROUND`],
+    background: process.env[`${prefix}BACKGROUND`],
+    brand: process.env[`${prefix}BRAND`],
+    alternate: process.env[`${prefix}ALTERNATE`],
+    accent: process.env[`${prefix}ACCENT`],
+    link: process.env[`${prefix}LINK`],
+    discovery: process.env[`${prefix}DISCOVERY`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    debug: process.env[`${prefix}DEBUG`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    performance: process.env[`${prefix}PERFORMANCE`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`],
+    gradient
+  };
+};
+
+// ../config-tools/src/env/set-env.ts
+var setExtensionEnv = (extensionName, extension) => {
+  for (const key of Object.keys(extension ?? {})) {
+    if (extension[key]) {
+      const result = key?.replace(
+        /([A-Z])+/g,
+        (input) => input ? input[0]?.toUpperCase() + input.slice(1) : ""
+      ).split(/(?=[A-Z])|[.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
+      let extensionKey;
+      if (result.length === 0) {
+        return;
+      }
+      if (result.length === 1) {
+        extensionKey = result[0]?.toUpperCase() ?? "";
+      } else {
+        extensionKey = result.reduce((ret, part) => {
+          return `${ret}_${part.toLowerCase()}`;
+        });
+      }
+      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] = extension[key];
+    }
+  }
+};
+var setConfigEnv = (config) => {
+  const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = Array.isArray(config.extends) ? JSON.stringify(config.extends) : config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  if (config.variant) {
+    process.env[`${prefix}VARIANT`] = config.variant;
+  }
+  if (config.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config.namespace;
+  }
+  if (config.owner) {
+    process.env[`${prefix}OWNER`] = config.owner;
+  }
+  if (config.bot) {
+    process.env[`${prefix}BOT_NAME`] = config.bot.name;
+    process.env[`${prefix}BOT_EMAIL`] = config.bot.email;
+  }
+  if (config.error) {
+    process.env[`${prefix}ERROR_CODES_FILE`] = config.error.codesFile;
+    process.env[`${prefix}ERROR_URL`] = config.error.url;
+  }
+  if (config.release) {
+    if (config.release.banner) {
+      if (typeof config.release.banner === "string") {
+        process.env[`${prefix}RELEASE_BANNER`] = config.release.banner;
+        process.env[`${prefix}RELEASE_BANNER_URL`] = config.release.banner;
+      } else {
+        process.env[`${prefix}RELEASE_BANNER`] = config.release.banner.url;
+        process.env[`${prefix}RELEASE_BANNER_URL`] = config.release.banner.url;
+        process.env[`${prefix}RELEASE_BANNER_ALT`] = config.release.banner.alt;
+      }
+    }
+    process.env[`${prefix}RELEASE_HEADER`] = config.release.header;
+    process.env[`${prefix}RELEASE_FOOTER`] = config.release.footer;
+  }
+  if (config.socials) {
+    if (config.socials.twitter) {
+      process.env[`${prefix}SOCIAL_TWITTER`] = config.socials.twitter;
+    }
+    if (config.socials.discord) {
+      process.env[`${prefix}SOCIAL_DISCORD`] = config.socials.discord;
+    }
+    if (config.socials.telegram) {
+      process.env[`${prefix}SOCIAL_TELEGRAM`] = config.socials.telegram;
+    }
+    if (config.socials.slack) {
+      process.env[`${prefix}SOCIAL_SLACK`] = config.socials.slack;
+    }
+    if (config.socials.medium) {
+      process.env[`${prefix}SOCIAL_MEDIUM`] = config.socials.medium;
+    }
+    if (config.socials.github) {
+      process.env[`${prefix}SOCIAL_GITHUB`] = config.socials.github;
+    }
+  }
+  if (config.organization) {
+    if (typeof config.organization === "string") {
+      process.env[`${prefix}ORG`] = config.organization;
+      process.env[`${prefix}ORG_NAME`] = config.organization;
+      process.env[`${prefix}ORGANIZATION`] = config.organization;
+      process.env[`${prefix}ORGANIZATION_NAME`] = config.organization;
+    } else {
+      process.env[`${prefix}ORG`] = config.organization.name;
+      process.env[`${prefix}ORG_NAME`] = config.organization.name;
+      process.env[`${prefix}ORGANIZATION`] = config.organization.name;
+      process.env[`${prefix}ORGANIZATION_NAME`] = config.organization.name;
+      if (config.organization.url) {
+        process.env[`${prefix}ORG_URL`] = config.organization.url;
+        process.env[`${prefix}ORGANIZATION_URL`] = config.organization.url;
+      }
+      if (config.organization.description) {
+        process.env[`${prefix}ORG_DESCRIPTION`] = config.organization.description;
+        process.env[`${prefix}ORGANIZATION_DESCRIPTION`] = config.organization.description;
+      }
+      if (config.organization.logo) {
+        process.env[`${prefix}ORG_LOGO`] = config.organization.logo;
+        process.env[`${prefix}ORGANIZATION_LOGO`] = config.organization.logo;
+      }
+      if (config.organization.icon) {
+        process.env[`${prefix}ORG_ICON`] = config.organization.icon;
+        process.env[`${prefix}ORGANIZATION_ICON`] = config.organization.icon;
+      }
+    }
+  }
+  if (config.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
+  }
+  if (config.license) {
+    process.env[`${prefix}LICENSE`] = config.license;
+  }
+  if (config.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  }
+  if (config.docs) {
+    process.env[`${prefix}DOCS`] = config.docs;
+  }
+  if (config.portal) {
+    process.env[`${prefix}PORTAL`] = config.portal;
+  }
+  if (config.licensing) {
+    process.env[`${prefix}LICENSING`] = config.licensing;
+  }
+  if (config.contact) {
+    process.env[`${prefix}CONTACT`] = config.contact;
+  }
+  if (config.support) {
+    process.env[`${prefix}SUPPORT`] = config.support;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+    process.env.TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}WORKSPACE_CONFIG_FILE`] = correctPaths(
+      config.configFile
+    );
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config.workspaceRoot);
+  }
+  if (config.directories) {
+    if (!config.skipCache && config.directories.cache) {
+      process.env[`${prefix}CACHE_DIR`] = correctPaths(
+        config.directories.cache
+      );
+      process.env[`${prefix}CACHE_DIRECTORY`] = process.env[`${prefix}CACHE_DIR`];
+    }
+    if (config.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = correctPaths(config.directories.data);
+      process.env[`${prefix}DATA_DIRECTORY`] = process.env[`${prefix}DATA_DIR`];
+    }
+    if (config.directories.config) {
+      process.env[`${prefix}CONFIG_DIR`] = correctPaths(
+        config.directories.config
+      );
+      process.env[`${prefix}CONFIG_DIRECTORY`] = process.env[`${prefix}CONFIG_DIR`];
+    }
+    if (config.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = correctPaths(config.directories.temp);
+      process.env[`${prefix}TEMP_DIRECTORY`] = process.env[`${prefix}TEMP_DIR`];
+    }
+    if (config.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = correctPaths(config.directories.log);
+      process.env[`${prefix}LOG_DIRECTORY`] = process.env[`${prefix}LOG_DIR`];
+    }
+    if (config.directories.build) {
+      process.env[`${prefix}BUILD_DIR`] = correctPaths(
+        config.directories.build
+      );
+      process.env[`${prefix}BUILD_DIRECTORY`] = process.env[`${prefix}BUILD_DIR`];
+    }
+  }
+  if (config.skipCache !== void 0) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
+    if (config.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
+    }
+  }
+  if (config.mode) {
+    process.env[`${prefix}MODE`] = config.mode;
+    process.env.NODE_ENV = config.mode;
+    process.env.ENVIRONMENT = config.mode;
+  }
+  if (config.colors?.base?.light || config.colors?.base?.dark) {
+    for (const key of Object.keys(config.colors)) {
+      setThemeColorsEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
+    }
+  } else {
+    setThemeColorsEnv(
+      `${prefix}COLOR_`,
+      config.colors
+    );
+  }
+  if (config.repository) {
+    process.env[`${prefix}REPOSITORY`] = config.repository;
+  }
+  if (config.branch) {
+    process.env[`${prefix}BRANCH`] = config.branch;
+  }
+  if (config.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config.preid);
+  }
+  if (config.registry) {
+    if (config.registry.github) {
+      process.env[`${prefix}REGISTRY_GITHUB`] = String(config.registry.github);
+    }
+    if (config.registry.npm) {
+      process.env[`${prefix}REGISTRY_NPM`] = String(config.registry.npm);
+    }
+    if (config.registry.cargo) {
+      process.env[`${prefix}REGISTRY_CARGO`] = String(config.registry.cargo);
+    }
+    if (config.registry.cyclone) {
+      process.env[`${prefix}REGISTRY_CYCLONE`] = String(
+        config.registry.cyclone
+      );
+    }
+    if (config.registry.container) {
+      process.env[`${prefix}REGISTRY_CONTAINER`] = String(
+        config.registry.container
+      );
+    }
+  }
+  if (config.logLevel) {
+    process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
+    process.env.LOG_LEVEL = String(config.logLevel);
+    process.env.NX_VERBOSE_LOGGING = String(
+      getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false
+    );
+    process.env.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
+  }
+  if (config.skipConfigLogging !== void 0) {
+    process.env[`${prefix}SKIP_CONFIG_LOGGING`] = String(
+      config.skipConfigLogging
+    );
+  }
+  process.env[`${prefix}WORKSPACE_CONFIG`] = JSON.stringify(config);
+  for (const key of Object.keys(config.extensions ?? {})) {
+    if (config.extensions[key] && Object.keys(config.extensions[key])) {
+      setExtensionEnv(key, config.extensions[key]);
+    }
+  }
+};
+var setThemeColorsEnv = (prefix, config) => {
+  return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorsEnv(prefix, config) : setSingleThemeColorsEnv(prefix, config);
+};
+var setSingleThemeColorsEnv = (prefix, config) => {
+  if (config.dark) {
+    process.env[`${prefix}DARK`] = config.dark;
+  }
+  if (config.light) {
+    process.env[`${prefix}LIGHT`] = config.light;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.discovery) {
+    process.env[`${prefix}DISCOVERY`] = config.discovery;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.debug) {
+    process.env[`${prefix}DEBUG`] = config.debug;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.performance) {
+    process.env[`${prefix}PERFORMANCE`] = config.performance;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+  if (config.gradient) {
+    for (let i = 0; i < config.gradient.length; i++) {
+      process.env[`${prefix}GRADIENT_${i}`] = config.gradient[i];
+    }
+  }
+};
+var setMultiThemeColorsEnv = (prefix, config) => {
+  return {
+    light: setBaseThemeColorsEnv(`${prefix}LIGHT_`, config.light),
+    dark: setBaseThemeColorsEnv(`${prefix}DARK_`, config.dark)
+  };
+};
+var setBaseThemeColorsEnv = (prefix, config) => {
+  if (config.foreground) {
+    process.env[`${prefix}FOREGROUND`] = config.foreground;
+  }
+  if (config.background) {
+    process.env[`${prefix}BACKGROUND`] = config.background;
+  }
+  if (config.brand) {
+    process.env[`${prefix}BRAND`] = config.brand;
+  }
+  if (config.alternate) {
+    process.env[`${prefix}ALTERNATE`] = config.alternate;
+  }
+  if (config.accent) {
+    process.env[`${prefix}ACCENT`] = config.accent;
+  }
+  if (config.link) {
+    process.env[`${prefix}LINK`] = config.link;
+  }
+  if (config.discovery) {
+    process.env[`${prefix}DISCOVERY`] = config.discovery;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  if (config.debug) {
+    process.env[`${prefix}DEBUG`] = config.debug;
+  }
+  if (config.warning) {
+    process.env[`${prefix}WARNING`] = config.warning;
+  }
+  if (config.danger) {
+    process.env[`${prefix}DANGER`] = config.danger;
+  }
+  if (config.fatal) {
+    process.env[`${prefix}FATAL`] = config.fatal;
+  }
+  if (config.performance) {
+    process.env[`${prefix}PERFORMANCE`] = config.performance;
+  }
+  if (config.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+  if (config.gradient) {
+    for (let i = 0; i < config.gradient.length; i++) {
+      process.env[`${prefix}GRADIENT_${i}`] = config.gradient[i];
+    }
+  }
+};
+var _static_cache = void 0;
+var createStormWorkspaceConfig = async (extensionName, schema, workspaceRoot, skipLogs = false, useDefault = true) => {
+  let result;
+  if (!_static_cache?.data || !_static_cache?.timestamp || _static_cache.timestamp < Date.now() - 8e3) {
+    let _workspaceRoot = workspaceRoot;
+    if (!_workspaceRoot) {
+      _workspaceRoot = findWorkspaceRoot();
+    }
+    const configEnv = getConfigEnv();
+    const configFile = await getConfigFile(_workspaceRoot);
+    if (!configFile) {
+      if (!skipLogs) {
+        writeWarning(
+          "No Storm Workspace configuration file found in the current repository. Please ensure this is the expected behavior - you can add a `storm-workspace.json` file to the root of your workspace if it is not.\n",
+          { logLevel: "all" }
+        );
+      }
+      if (useDefault === false) {
+        return void 0;
+      }
+    }
+    const defaultConfig = await getPackageJsonConfig(_workspaceRoot);
+    const configInput = defu__default.default(
+      configEnv,
+      configFile,
+      defaultConfig
+    );
+    if (!configInput.variant) {
+      configInput.variant = fs.existsSync(joinPaths(_workspaceRoot, "nx.json")) || fs.existsSync(joinPaths(_workspaceRoot, ".nx")) || fs.existsSync(joinPaths(_workspaceRoot, "lerna.json")) || fs.existsSync(joinPaths(_workspaceRoot, "turbo.json")) ? "monorepo" : "minimal";
+    }
+    try {
+      const parseResult = await Promise.resolve(
+        workspaceConfigSchema._zod.parse(
+          { value: configInput, issues: [] },
+          { async: true }
+        )
+      );
+      result = applyDefaultConfig(parseResult.value);
+      result.workspaceRoot ??= _workspaceRoot;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Storm Workspace configuration${error?.message ? `: ${error.message}` : ""}
+
+Please ensure your configuration file is valid JSON and matches the expected schema. The current workspace configuration input is: ${formatLogMessage(
+          configInput
+        )}`,
+        {
+          cause: error
+        }
+      );
+    }
+  } else {
+    result = _static_cache.data;
+  }
+  _static_cache = {
+    timestamp: Date.now(),
+    data: result
+  };
+  return result;
+};
+var loadStormWorkspaceConfig = async (workspaceRoot, skipLogs = false) => {
+  const config = await createStormWorkspaceConfig(
+    void 0,
+    void 0,
+    workspaceRoot,
+    skipLogs,
+    true
+  );
+  setConfigEnv(config);
+  if (!skipLogs && !config.skipConfigLogging) {
+    writeTrace(
+      `\u2699\uFE0F  Using Storm Workspace configuration: 
+${formatLogMessage(config)}`,
+      config
+    );
+  }
+  return config;
+};
+
+// ../config-tools/src/get-config.ts
+function getConfig(workspaceRoot, skipLogs = false) {
+  return loadStormWorkspaceConfig(workspaceRoot, skipLogs);
+}
+function getWorkspaceConfig(skipLogs = true, options = {}) {
+  let workspaceRoot = options.workspaceRoot;
+  if (!workspaceRoot) {
+    workspaceRoot = findWorkspaceRoot(options.cwd);
+  }
+  return getConfig(workspaceRoot, skipLogs);
+}
+
+exports.STORM_DEFAULT_RELEASE_BANNER = STORM_DEFAULT_RELEASE_BANNER;
+exports.__require = __require;
+exports.brandIcon = brandIcon;
+exports.exitWithError = exitWithError;
+exports.exitWithSuccess = exitWithSuccess;
+exports.findWorkspaceRootSafe = findWorkspaceRootSafe;
+exports.formatLogMessage = formatLogMessage;
+exports.getConfig = getConfig;
+exports.getWorkspaceConfig = getWorkspaceConfig;
+exports.handleProcess = handleProcess;
+exports.isVerbose = isVerbose;
+exports.joinPaths = joinPaths;
+exports.writeDebug = writeDebug;
+exports.writeFatal = writeFatal;
+exports.writeInfo = writeInfo;
+exports.writeSuccess = writeSuccess;
+exports.writeTrace = writeTrace;
+exports.writeWarning = writeWarning;
+//# sourceMappingURL=chunk-TOLGVHZM.cjs.map
+//# sourceMappingURL=chunk-TOLGVHZM.cjs.map