@storm-software/unbuild 0.17.1 → 0.17.2

package/bin/unbuild.cjs

@@ -23,42 +23,1346 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../config/src/schema.ts
+var import_zod = __toESM(require("zod"));
+
+// ../config/src/constants.ts
+var STORM_DEFAULT_DOCS = "https://docs.stormsoftware.com";
+var STORM_DEFAULT_HOMEPAGE = "https://stormsoftware.com";
+var STORM_DEFAULT_LICENSING = "https://license.stormsoftware.com";
+var STORM_DEFAULT_LICENSE = "Apache-2.0";
+
+// ../config/src/schema.ts
+var DarkColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1d1e22").describe("The dark background color of the workspace");
+var LightColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#f4f4f5").describe("The light background color of the workspace");
+var BrandColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#1fb2a6").describe("The primary brand specific color of the workspace");
+var AlternateColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The alternate brand specific color of the workspace");
+var AccentColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The secondary brand specific color of the workspace");
+var LinkColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The color used to display hyperlink text");
+var HelpColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#8256D0").describe("The second brand specific color of the workspace");
+var SuccessColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#12B66A").describe("The success color of the workspace");
+var InfoColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#0070E0").describe("The informational color of the workspace");
+var WarningColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#fcc419").describe("The warning color of the workspace");
+var DangerColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#D8314A").describe("The danger color of the workspace");
+var FatalColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).optional().describe("The fatal color of the workspace");
+var PositiveColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#4ade80").describe("The positive number color of the workspace");
+var NegativeColorSchema = import_zod.default.string().trim().toLowerCase().regex(/^#([0-9a-f]{3}){1,2}$/i).length(7).default("#ef4444").describe("The negative number color of the workspace");
+var DarkThemeColorConfigSchema = import_zod.default.object({
+  foreground: LightColorSchema,
+  background: DarkColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var LightThemeColorConfigSchema = import_zod.default.object({
+  foreground: DarkColorSchema,
+  background: LightColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var MultiThemeColorConfigSchema = import_zod.default.object({
+  dark: DarkThemeColorConfigSchema,
+  light: LightThemeColorConfigSchema
+});
+var SingleThemeColorConfigSchema = import_zod.default.object({
+  dark: DarkColorSchema,
+  light: LightColorSchema,
+  brand: BrandColorSchema,
+  alternate: AlternateColorSchema,
+  accent: AccentColorSchema,
+  link: LinkColorSchema,
+  help: HelpColorSchema,
+  success: SuccessColorSchema,
+  info: InfoColorSchema,
+  warning: WarningColorSchema,
+  danger: DangerColorSchema,
+  fatal: FatalColorSchema,
+  positive: PositiveColorSchema,
+  negative: NegativeColorSchema
+});
+var RegistryUrlConfigSchema = import_zod.default.string().trim().toLowerCase().url().optional().describe("A remote registry URL used to publish distributable packages");
+var RegistryConfigSchema = import_zod.default.object({
+  github: RegistryUrlConfigSchema,
+  npm: RegistryUrlConfigSchema,
+  cargo: RegistryUrlConfigSchema,
+  cyclone: RegistryUrlConfigSchema,
+  container: RegistryUrlConfigSchema
+}).default({}).describe("A list of remote registry URLs used by Storm Software");
+var ColorConfigSchema = SingleThemeColorConfigSchema.or(MultiThemeColorConfigSchema).describe("Colors used for various workspace elements");
+var ColorConfigMapSchema = import_zod.default.union([
+  import_zod.default.object({
+    "base": ColorConfigSchema
+  }),
+  import_zod.default.record(import_zod.default.string(), ColorConfigSchema)
+]);
+var WorkspaceBotConfigSchema = import_zod.default.object({
+  name: import_zod.default.string().trim().default("Stormie-Bot").describe("The workspace bot user's name (this is the bot that will be used to perform various tasks)"),
+  email: import_zod.default.string().trim().email().default("bot@stormsoftware.com").describe("The email of the workspace bot")
+}).describe("The workspace's bot user's config used to automated various operations tasks");
+var WorkspaceDirectoryConfigSchema = import_zod.default.object({
+  cache: import_zod.default.string().trim().optional().describe("The directory used to store the environment's cached file data"),
+  data: import_zod.default.string().trim().optional().describe("The directory used to store the environment's data files"),
+  config: import_zod.default.string().trim().optional().describe("The directory used to store the environment's configuration files"),
+  temp: import_zod.default.string().trim().optional().describe("The directory used to store the environment's temp files"),
+  log: import_zod.default.string().trim().optional().describe("The directory used to store the environment's temp files"),
+  build: import_zod.default.string().trim().default("dist").describe("The directory used to store the workspace's distributable files after a build (relative to the workspace root)")
+}).describe("Various directories used by the workspace to store data, cache, and configuration files");
+var StormConfigSchema = import_zod.default.object({
+  $schema: import_zod.default.string().trim().default("https://cdn.jsdelivr.net/npm/@storm-software/config/schemas/storm.schema.json").optional().nullish().describe("The URL to the JSON schema file that describes the Storm configuration file"),
+  extends: import_zod.default.string().trim().optional().describe("The path to a base JSON file to use as a configuration preset file"),
+  name: import_zod.default.string().trim().toLowerCase().optional().describe("The name of the service/package/scope using this configuration"),
+  namespace: import_zod.default.string().trim().toLowerCase().optional().describe("The namespace of the package"),
+  organization: import_zod.default.string().trim().default("storm-software").describe("The organization of the workspace"),
+  repository: import_zod.default.string().trim().url().optional().describe("The repo URL of the workspace (i.e. GitHub)"),
+  license: import_zod.default.string().trim().default("Apache-2.0").describe("The license type of the package"),
+  homepage: import_zod.default.string().trim().url().default(STORM_DEFAULT_HOMEPAGE).describe("The homepage of the workspace"),
+  docs: import_zod.default.string().trim().url().default(STORM_DEFAULT_DOCS).describe("The base documentation site for the workspace"),
+  licensing: import_zod.default.string().trim().url().default(STORM_DEFAULT_LICENSING).describe("The base licensing site for the workspace"),
+  branch: import_zod.default.string().trim().default("main").describe("The branch of the workspace"),
+  preid: import_zod.default.string().optional().describe("A tag specifying the version pre-release identifier"),
+  owner: import_zod.default.string().trim().default("@storm-software/admin").describe("The owner of the package"),
+  bot: WorkspaceBotConfigSchema,
+  env: import_zod.default.enum([
+    "development",
+    "staging",
+    "production"
+  ]).default("production").describe("The current runtime environment name for the package"),
+  workspaceRoot: import_zod.default.string().trim().default("").describe("The root directory of the workspace"),
+  externalPackagePatterns: import_zod.default.array(import_zod.default.string()).default([]).describe("The build will use these package patterns to determine if they should be external to the bundle"),
+  skipCache: import_zod.default.boolean().default(false).describe("Should all known types of workspace caching be skipped?"),
+  directories: WorkspaceDirectoryConfigSchema,
+  packageManager: import_zod.default.enum([
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun"
+  ]).default("npm").describe("The JavaScript/TypeScript package manager used by the repository"),
+  timezone: import_zod.default.string().trim().default("America/New_York").describe("The default timezone of the workspace"),
+  locale: import_zod.default.string().trim().default("en-US").describe("The default locale of the workspace"),
+  logLevel: import_zod.default.enum([
+    "silent",
+    "fatal",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace",
+    "all"
+  ]).default("info").describe("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`)."),
+  registry: RegistryConfigSchema,
+  configFile: import_zod.default.string().trim().nullable().default(null).describe("The filepath of the Storm config. When this field is null, no config file was found in the current workspace."),
+  colors: ColorConfigSchema.or(ColorConfigMapSchema).describe("Storm theme config values used for styling various package elements"),
+  extensions: import_zod.default.record(import_zod.default.any()).optional().default({}).describe("Configuration of each used extension")
+}).describe("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/create-storm-config.ts
+var import_defu2 = __toESM(require("defu"));
+
+// ../config-tools/src/config-file/get-config-file.ts
+var import_c12 = require("c12");
+var import_defu = __toESM(require("defu"));
+
+// ../config-tools/src/types.ts
+var LogLevel = {
+  SILENT: 0,
+  FATAL: 10,
+  ERROR: 20,
+  WARN: 30,
+  SUCCESS: 35,
+  INFO: 40,
+  DEBUG: 60,
+  TRACE: 70,
+  ALL: 100
+};
+var LogLevelLabel = {
+  SILENT: "silent",
+  FATAL: "fatal",
+  ERROR: "error",
+  WARN: "warn",
+  INFO: "info",
+  DEBUG: "debug",
+  TRACE: "trace",
+  ALL: "all"
+};
+
+// ../config/src/types.ts
+var COLOR_KEYS = [
+  "dark",
+  "light",
+  "base",
+  "brand",
+  "alternate",
+  "accent",
+  "link",
+  "success",
+  "help",
+  "info",
+  "warning",
+  "danger",
+  "fatal",
+  "positive",
+  "negative"
+];
+
+// ../config-tools/src/utilities/get-default-config.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// ../config-tools/src/utilities/correct-paths.ts
+var import_devkit = require("@nx/devkit");
+var correctPaths = /* @__PURE__ */ __name((path2) => {
+  if (!path2) {
+    return "";
+  }
+  if (!path2.toUpperCase().startsWith("C:") && path2.includes("\\")) {
+    path2 = `C:${path2}`;
+  }
+  return path2.replaceAll("\\", "/");
+}, "correctPaths");
+var joinPaths = /* @__PURE__ */ __name((...paths) => {
+  if (!paths || paths.length === 0) {
+    return "";
+  }
+  return correctPaths((0, import_devkit.joinPathFragments)(...paths.map((path2) => correctPaths(path2))));
+}, "joinPaths");
+
+// ../config-tools/src/utilities/find-up.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames) {
+  const _startPath = startPath ?? process.cwd();
+  if (endFileNames.some((endFileName) => (0, import_node_fs.existsSync)((0, import_node_path.join)(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = (0, import_node_path.join)(_startPath, "..");
+    return findFolderUp(parent, endFileNames);
+  }
+  return void 0;
+}
+__name(findFolderUp, "findFolderUp");
+
+// ../config-tools/src/utilities/find-workspace-root.ts
+var rootFiles = [
+  "storm.json",
+  "storm.json",
+  "storm.yaml",
+  "storm.yml",
+  "storm.js",
+  "storm.ts",
+  ".storm.json",
+  ".storm.yaml",
+  ".storm.yml",
+  ".storm.js",
+  ".storm.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"
+];
+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));
+}
+__name(findWorkspaceRootSafe, "findWorkspaceRootSafe");
+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;
+}
+__name(findWorkspaceRoot, "findWorkspaceRoot");
+
+// ../config-tools/src/utilities/get-default-config.ts
+var DEFAULT_COLOR_CONFIG = {
+  "light": {
+    "background": "#fafafa",
+    "foreground": "#1d1e22",
+    "brand": "#1fb2a6",
+    "alternate": "#db2777",
+    "help": "#5C4EE5",
+    "success": "#087f5b",
+    "info": "#0550ae",
+    "warning": "#e3b341",
+    "danger": "#D8314A",
+    "positive": "#22c55e",
+    "negative": "#dc2626"
+  },
+  "dark": {
+    "background": "#1d1e22",
+    "foreground": "#cbd5e1",
+    "brand": "#2dd4bf",
+    "alternate": "#db2777",
+    "help": "#818cf8",
+    "success": "#10b981",
+    "info": "#58a6ff",
+    "warning": "#f3d371",
+    "danger": "#D8314A",
+    "positive": "#22c55e",
+    "negative": "#dc2626"
+  }
+};
+var getDefaultConfig = /* @__PURE__ */ __name((root) => {
+  let license = STORM_DEFAULT_LICENSE;
+  let homepage = STORM_DEFAULT_HOMEPAGE;
+  let name;
+  let namespace;
+  let repository;
+  const workspaceRoot = findWorkspaceRoot(root);
+  if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(workspaceRoot, "package.json"))) {
+    const file = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(workspaceRoot, "package.json"), {
+      encoding: "utf8"
+    });
+    if (file) {
+      const packageJson = JSON.parse(file);
+      if (packageJson.name) {
+        name = packageJson.name;
+      }
+      if (packageJson.namespace) {
+        namespace = packageJson.namespace;
+      }
+      if (packageJson.repository?.url) {
+        repository = packageJson.repository?.url;
+      }
+      if (packageJson.license) {
+        license = packageJson.license;
+      }
+      if (packageJson.homepage) {
+        homepage = packageJson.homepage;
+      }
+    }
+  }
+  return {
+    workspaceRoot,
+    name,
+    namespace,
+    repository,
+    license,
+    homepage,
+    docs: `${homepage || STORM_DEFAULT_HOMEPAGE}/docs`,
+    licensing: `${homepage || STORM_DEFAULT_HOMEPAGE}/license`
+  };
+}, "getDefaultConfig");
+
+// ../config-tools/src/logger/chalk.ts
+var import_chalk = __toESM(require("chalk"));
+var chalkDefault = {
+  hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
+  bgHex: /* @__PURE__ */ __name((_) => ({
+    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+  }), "bgHex"),
+  whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright"),
+  bold: {
+    hex: /* @__PURE__ */ __name((_) => (message) => message, "hex"),
+    bgHex: /* @__PURE__ */ __name((_) => ({
+      whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+    }), "bgHex"),
+    whiteBright: /* @__PURE__ */ __name((message) => message, "whiteBright")
+  }
+};
+var getChalk = /* @__PURE__ */ __name(() => {
+  let _chalk = import_chalk.default;
+  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright) {
+    _chalk = chalkDefault;
+  }
+  return _chalk;
+}, "getChalk");
+
+// ../config-tools/src/logger/get-log-level.ts
+var getLogLevel = /* @__PURE__ */ __name((label) => {
+  switch (label) {
+    case "all":
+      return LogLevel.ALL;
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    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;
+  }
+}, "getLogLevel");
+var getLogLevelLabel = /* @__PURE__ */ __name((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.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;
+}, "getLogLevelLabel");
+var isVerbose = /* @__PURE__ */ __name((label = LogLevelLabel.SILENT) => {
+  const logLevel = typeof label === "string" ? getLogLevel(label) : label;
+  return logLevel <= LogLevel.DEBUG;
+}, "isVerbose");
+
+// ../config-tools/src/logger/console.ts
+var getLogFn = /* @__PURE__ */ __name((logLevel = LogLevel.INFO, config = {}) => {
+  const _chalk = getChalk();
+  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 (typeof logLevel === "number" && (logLevel >= getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT) || typeof logLevel === "string" && getLogLevel(logLevel) >= getLogLevel(configLogLevel)) {
+    return (_) => {
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel || typeof logLevel === "string" && LogLevel.FATAL >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.error(`${_chalk.bold.hex(colors.fatal ?? "#7d1a1a")(">")} ${_chalk.bold.bgHex(colors.fatal ?? "#7d1a1a").whiteBright(" \u{1F480} Fatal ")}  ${_chalk.hex(colors.fatal ?? "#7d1a1a")(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel || typeof logLevel === "string" && LogLevel.ERROR >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.error(`${_chalk.bold.hex(colors.danger ?? "#f85149")(">")} ${_chalk.bold.bgHex(colors.danger ?? "#f85149").whiteBright(" \u2718  Error ")}  ${_chalk.hex(colors.danger ?? "#f85149")(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel || typeof logLevel === "string" && LogLevel.WARN >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.warn(`${_chalk.bold.hex(colors.warning ?? "#e3b341")(">")} ${_chalk.bold.bgHex(colors.warning ?? "#e3b341").whiteBright("  \u26A0 Warn  ")}  ${_chalk.hex(colors.warning ?? "#e3b341")(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel || typeof logLevel === "string" && LogLevel.SUCCESS >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.info(`${_chalk.bold.hex(colors.success ?? "#56d364")(">")} ${_chalk.bold.bgHex(colors.success ?? "#56d364").whiteBright(" \u2713 Success ")}  ${_chalk.hex(colors.success ?? "#56d364")(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel || typeof logLevel === "string" && LogLevel.INFO >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.info(`${_chalk.bold.hex(colors.info ?? "#58a6ff")(">")} ${_chalk.bold.bgHex(colors.info ?? "#58a6ff").whiteBright("  \u2139 Info  ")}  ${_chalk.hex(colors.info ?? "#58a6ff")(formatLogMessage(message))}
+`);
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel || typeof logLevel === "string" && LogLevel.TRACE >= getLogLevel(logLevel)) {
+    return (message) => {
+      console.debug(`${_chalk.bold.hex(colors.brand ?? "#1fb2a6")(">")} ${_chalk.bold.bgHex(colors.brand ?? "#1fb2a6").whiteBright(" \u{1F6E0}  Debug ")}  ${_chalk.hex(colors.brand ?? "#1fb2a6")(formatLogMessage(message))}
+`);
+    };
+  }
+  return (message) => {
+    console.log(`${_chalk.bold.hex(colors.brand ?? "#1fb2a6")(">")} ${_chalk.bold.bgHex(colors.brand ?? "#1fb2a6").whiteBright(" \u2709 System ")}  ${_chalk.hex(colors.brand ?? "#1fb2a6")(formatLogMessage(message))}
+`);
+  };
+}, "getLogFn");
+var writeFatal = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.FATAL, config)(message), "writeFatal");
+var writeError = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.ERROR, config)(message), "writeError");
+var writeWarning = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.WARN, config)(message), "writeWarning");
+var writeInfo = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.INFO, config)(message), "writeInfo");
+var writeSuccess = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.SUCCESS, config)(message), "writeSuccess");
+var writeDebug = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.DEBUG, config)(message), "writeDebug");
+var writeTrace = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.TRACE, config)(message), "writeTrace");
+var writeSystem = /* @__PURE__ */ __name((message, config) => getLogFn(LogLevel.ALL, config)(message), "writeSystem");
+var getStopwatch = /* @__PURE__ */ __name((name) => {
+  const start = process.hrtime();
+  return () => {
+    const end = process.hrtime(start);
+    console.info(`
+>  \u23F1\uFE0F  The${name ? ` ${name}` : ""} process took ${Math.round(end[0] * 1e3 + end[1] / 1e6)}ms to complete
+
+`);
+  };
+}, "getStopwatch");
+var MAX_DEPTH = 4;
+var formatLogMessage = /* @__PURE__ */ __name((message, options = {}, depth2 = 0) => {
+  if (depth2 > MAX_DEPTH) {
+    return "<max depth>";
+  }
+  const prefix = options.prefix ?? "-";
+  const skip = options.skip ?? [];
+  return typeof message === "undefined" || message === null || !message && typeof message !== "boolean" ? "<none>" : typeof message === "string" ? message : Array.isArray(message) ? `
+${message.map((item, index) => ` ${prefix}> #${index} = ${formatLogMessage(item, {
+    prefix: `${prefix}-`,
+    skip
+  }, depth2 + 1)}`).join("\n")}` : typeof message === "object" ? `
+${Object.keys(message).filter((key) => !skip.includes(key)).map((key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" ? formatLogMessage(message[key], {
+    prefix: `${prefix}-`,
+    skip
+  }, depth2 + 1) : message[key]}`).join("\n")}` : message;
+}, "formatLogMessage");
+var _isFunction = /* @__PURE__ */ __name((value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+// ../config-tools/src/utilities/process-handler.ts
+var exitWithError = /* @__PURE__ */ __name((config) => {
+  writeFatal("Exiting script with an error status...", config);
+  process.exit(1);
+}, "exitWithError");
+var exitWithSuccess = /* @__PURE__ */ __name((config) => {
+  writeSuccess("Script completed successfully. Exiting...", config);
+  process.exit(0);
+}, "exitWithSuccess");
+var handleProcess = /* @__PURE__ */ __name((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}`, config);
+    exitWithError(config);
+  });
+  process.on("uncaughtException", (error) => {
+    writeError(`An Uncaught Exception occurred while running the program: ${error.message} 
+Stacktrace: ${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);
+  });
+}, "handleProcess");
+
+// ../config-tools/src/config-file/get-config-file.ts
+var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || findWorkspaceRoot(filePath);
+  let config = (0, import_c12.loadConfig)({
+    cwd: workspacePath,
+    packageJson: true,
+    name: fileName,
+    envName: fileName?.toUpperCase(),
+    jitiOptions: {
+      debug: false,
+      cache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache", "storm")
+    },
+    ...options
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = (0, import_c12.loadConfig)({
+      cwd: workspacePath,
+      packageJson: true,
+      name: fileName,
+      envName: fileName?.toUpperCase(),
+      jitiOptions: {
+        debug: false,
+        cache: process.env.STORM_SKIP_CACHE === "true" ? false : joinPaths(process.env.STORM_CACHE_DIR || "node_modules/.cache", "storm")
+      },
+      configFile: fileName,
+      ...options
+    });
+  }
+  return config;
+}, "getConfigFileByName");
+var getConfigFile = /* @__PURE__ */ __name(async (filePath, additionalFileNames = []) => {
+  const workspacePath = filePath ? filePath : findWorkspaceRoot(filePath);
+  const result = await getConfigFileByName("storm", workspacePath);
+  let config = result.config;
+  const configFile = result.configFile;
+  if (config && configFile && Object.keys(config).length > 0) {
+    writeSystem(`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) {
+        writeSystem(`Found alternative configuration file "${result2.configFile.includes(`${workspacePath}/`) ? result2.configFile.replace(`${workspacePath}/`, "") : result2.configFile}" at "${workspacePath}"`, {
+          logLevel: "all"
+        });
+        config = (0, import_defu.default)(result2.config ?? {}, config ?? {});
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+// ../config-tools/src/env/get-env.ts
+var getConfigEnv = /* @__PURE__ */ __name(() => {
+  const prefix = "STORM_";
+  let config = {
+    extends: process.env[`${prefix}EXTENDS`] || void 0,
+    name: process.env[`${prefix}NAME`] || 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
+    },
+    organization: process.env[`${prefix}ORGANIZATION`] || 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,
+    licensing: process.env[`${prefix}LICENSING`] || 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}CONFIG_FILE`] ? correctPaths(process.env[`${prefix}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`]) : void 0,
+      data: process.env[`${prefix}DATA_DIR`] ? correctPaths(process.env[`${prefix}DATA_DIR`]) : void 0,
+      config: process.env[`${prefix}CONFIG_DIR`] ? correctPaths(process.env[`${prefix}CONFIG_DIR`]) : void 0,
+      temp: process.env[`${prefix}TEMP_DIR`] ? correctPaths(process.env[`${prefix}TEMP_DIR`]) : void 0,
+      log: process.env[`${prefix}LOG_DIR`] ? correctPaths(process.env[`${prefix}LOG_DIR`]) : void 0,
+      build: process.env[`${prefix}BUILD_DIR`] ? correctPaths(process.env[`${prefix}BUILD_DIR`]) : void 0
+    },
+    skipCache: process.env[`${prefix}SKIP_CACHE`] !== void 0 ? Boolean(process.env[`${prefix}SKIP_CACHE`]) : void 0,
+    env: (process.env[`${prefix}ENV`] ?? 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,
+    externalPackagePatterns: process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] ? JSON.parse(process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`]) : [],
+    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
+  };
+  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] = getThemeColorConfigEnv(prefix, themeName);
+    return ret;
+  }, {}) : getThemeColorConfigEnv(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}CONFIG`];
+  if (serializedConfig) {
+    const parsed = JSON.parse(serializedConfig);
+    config = {
+      ...config,
+      ...parsed,
+      colors: {
+        ...config.colors,
+        ...parsed.colors
+      },
+      extensions: {
+        ...config.extensions,
+        ...parsed.extensions
+      }
+    };
+  }
+  return config;
+}, "getConfigEnv");
+var getThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, theme) => {
+  const themeName = `COLOR_${theme && theme !== "base" ? `${theme}_` : ""}`.toUpperCase();
+  return process.env[`${prefix}${themeName}LIGHT_BRAND`] || process.env[`${prefix}${themeName}DARK_BRAND`] ? getMultiThemeColorConfigEnv(prefix + themeName) : getSingleThemeColorConfigEnv(prefix + themeName);
+}, "getThemeColorConfigEnv");
+var getSingleThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+  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`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getSingleThemeColorConfigEnv");
+var getMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+  return {
+    light: getBaseThemeColorConfigEnv(`${prefix}_LIGHT_`),
+    dark: getBaseThemeColorConfigEnv(`${prefix}_DARK_`)
+  };
+}, "getMultiThemeColorConfigEnv");
+var getBaseThemeColorConfigEnv = /* @__PURE__ */ __name((prefix) => {
+  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`],
+    help: process.env[`${prefix}HELP`],
+    success: process.env[`${prefix}SUCCESS`],
+    info: process.env[`${prefix}INFO`],
+    warning: process.env[`${prefix}WARNING`],
+    danger: process.env[`${prefix}DANGER`],
+    fatal: process.env[`${prefix}FATAL`],
+    positive: process.env[`${prefix}POSITIVE`],
+    negative: process.env[`${prefix}NEGATIVE`]
+  };
+}, "getBaseThemeColorConfigEnv");
+
+// ../config-tools/src/env/set-env.ts
+var setExtensionEnv = /* @__PURE__ */ __name((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];
+    }
+  }
+}, "setExtensionEnv");
+var setConfigEnv = /* @__PURE__ */ __name((config) => {
+  const prefix = "STORM_";
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  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.organization) {
+    process.env[`${prefix}ORGANIZATION`] = config.organization;
+  }
+  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.licensing) {
+    process.env[`${prefix}LICENSING`] = config.licensing;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LANG = config.locale ? `${config.locale.replaceAll("-", "_")}.UTF-8` : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}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);
+    }
+    if (config.directories.data) {
+      process.env[`${prefix}DATA_DIR`] = correctPaths(config.directories.data);
+    }
+    if (config.directories.config) {
+      process.env[`${prefix}CONFIG_DIR`] = correctPaths(config.directories.config);
+    }
+    if (config.directories.temp) {
+      process.env[`${prefix}TEMP_DIR`] = correctPaths(config.directories.temp);
+    }
+    if (config.directories.log) {
+      process.env[`${prefix}LOG_DIR`] = correctPaths(config.directories.log);
+    }
+    if (config.directories.build) {
+      process.env[`${prefix}BUILD_DIR`] = correctPaths(config.directories.build);
+    }
+  }
+  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.env) {
+    process.env[`${prefix}ENV`] = config.env;
+    process.env.NODE_ENV = config.env;
+    process.env.ENVIRONMENT = config.env;
+  }
+  if (config.colors?.base?.light || config.colors?.base?.dark) {
+    for (const key of Object.keys(config.colors)) {
+      setThemeColorConfigEnv(`${prefix}COLOR_${key}_`, config.colors[key]);
+    }
+  } else {
+    setThemeColorConfigEnv(`${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.externalPackagePatterns) {
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(config.externalPackagePatterns);
+  }
+  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.cyclone);
+    }
+  }
+  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";
+  }
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config);
+  for (const key of Object.keys(config.extensions ?? {})) {
+    config.extensions[key] && Object.keys(config.extensions[key]) && setExtensionEnv(key, config.extensions[key]);
+  }
+}, "setConfigEnv");
+var setThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return config?.light?.brand || config?.dark?.brand ? setMultiThemeColorConfigEnv(prefix, config) : setSingleThemeColorConfigEnv(prefix, config);
+}, "setThemeColorConfigEnv");
+var setSingleThemeColorConfigEnv = /* @__PURE__ */ __name((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.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  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.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setSingleThemeColorConfigEnv");
+var setMultiThemeColorConfigEnv = /* @__PURE__ */ __name((prefix, config) => {
+  return {
+    light: setBaseThemeColorConfigEnv(`${prefix}LIGHT_`, config.light),
+    dark: setBaseThemeColorConfigEnv(`${prefix}DARK_`, config.dark)
+  };
+}, "setMultiThemeColorConfigEnv");
+var setBaseThemeColorConfigEnv = /* @__PURE__ */ __name((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.help) {
+    process.env[`${prefix}HELP`] = config.help;
+  }
+  if (config.success) {
+    process.env[`${prefix}SUCCESS`] = config.success;
+  }
+  if (config.info) {
+    process.env[`${prefix}INFO`] = config.info;
+  }
+  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.positive) {
+    process.env[`${prefix}POSITIVE`] = config.positive;
+  }
+  if (config.negative) {
+    process.env[`${prefix}NEGATIVE`] = config.negative;
+  }
+}, "setBaseThemeColorConfigEnv");
+
+// ../config-tools/src/create-storm-config.ts
+var _static_cache = void 0;
+var loadStormConfig = /* @__PURE__ */ __name(async (workspaceRoot) => {
+  let config = {};
+  if (_static_cache?.data && _static_cache?.timestamp && _static_cache.timestamp >= Date.now() + 3e4) {
+    writeTrace(`Configuration cache hit - ${_static_cache.timestamp}`, _static_cache.data);
+    return _static_cache.data;
+  }
+  let _workspaceRoot = workspaceRoot;
+  if (!_workspaceRoot) {
+    _workspaceRoot = findWorkspaceRoot();
+  }
+  const configFile = await getConfigFile(_workspaceRoot);
+  if (!configFile) {
+    writeWarning("No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.json` file to the root of your workspace if it is not.\n", {
+      logLevel: "all"
+    });
+  }
+  config = (0, import_defu2.default)(getConfigEnv(), configFile, getDefaultConfig(_workspaceRoot));
+  setConfigEnv(config);
+  writeTrace(`\u2699\uFE0F  Using Storm configuration: 
+${formatLogMessage(config)}`, config);
+  return config;
+}, "loadStormConfig");
+
 // bin/unbuild.ts
-var import_create_storm_config2 = require("@storm-software/config-tools/create-storm-config");
-var import_console4 = require("@storm-software/config-tools/logger/console");
-var import_find_workspace_root2 = require("@storm-software/config-tools/utilities/find-workspace-root");
-var import_process_handler = require("@storm-software/config-tools/utilities/process-handler");
 var import_commander = require("commander");
 
 // src/build.ts
+var import_node5 = require("@humanfs/node");
+var import_devkit6 = require("@nx/devkit");
+var import_js2 = require("@nx/js");
+var import_buildable_libs_utils4 = require("@nx/js/src/utils/buildable-libs-utils");
+
+// ../build-tools/src/plugins/swc.ts
+var import_core = require("@swc/core");
+
+// ../build-tools/src/plugins/ts-resolve.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_module = require("module");
+var import_node_path3 = __toESM(require("path"));
+var import_resolve = __toESM(require("resolve"));
+
+// ../build-tools/src/plugins/type-definitions.ts
+var import_devkit2 = require("@nx/devkit");
+var import_path = require("path");
+
+// ../build-tools/src/utilities/copy-assets.ts
 var import_node2 = require("@humanfs/node");
 var import_devkit3 = require("@nx/devkit");
 var import_js = require("@nx/js");
-var import_buildable_libs_utils3 = require("@nx/js/src/utils/buildable-libs-utils");
-var import_build_tools = require("@storm-software/build-tools");
-var import_create_storm_config = require("@storm-software/config-tools/create-storm-config");
-var import_console3 = require("@storm-software/config-tools/logger/console");
-var import_get_log_level = require("@storm-software/config-tools/logger/get-log-level");
-var import_types = require("@storm-software/config-tools/types");
-var import_correct_paths = require("@storm-software/config-tools/utilities/correct-paths");
-var import_defu = __toESM(require("defu"), 1);
-var import_node_path3 = require("path");
-var import_find_workspace_root = require("nx/src/utils/find-workspace-root");
+var import_glob = require("glob");
+
+// ../build-tools/src/utilities/read-nx-config.ts
+var import_node = require("@humanfs/node");
+var readNxConfig = /* @__PURE__ */ __name(async (workspaceRoot) => {
+  let rootDir = workspaceRoot;
+  if (!rootDir) {
+    const config = await loadStormConfig();
+    rootDir = config.workspaceRoot;
+  }
+  const nxJsonPath = joinPaths(rootDir, "nx.json");
+  if (!await import_node.hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  return import_node.hfs.json(nxJsonPath);
+}, "readNxConfig");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(assets ?? []);
+  if (!pendingAssets?.some((asset) => asset?.glob === "*.md")) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "*.md",
+      output: "/"
+    });
+  }
+  if (generatePackageJson2 === false) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (!pendingAssets?.some((asset) => asset?.glob === "LICENSE")) {
+    pendingAssets.push({
+      input: "",
+      glob: "LICENSE",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  const nxJson = readNxConfig(config.workspaceRoot);
+  const projectGraph = await (0, import_devkit3.createProjectGraphAsync)({
+    exitOnError: true
+  });
+  const projectsConfigurations = (0, import_devkit3.readProjectsConfigurationFromProjectGraph)(projectGraph);
+  if (!projectsConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const buildTarget = projectsConfigurations.projects[projectName]?.targets?.build;
+  if (!buildTarget) {
+    throw new Error(`The Build process failed because the project does not have a valid build target in the project.json file. Check if the file exists in the root of the project at ${joinPaths(projectRoot, "project.json")}`);
+  }
+  const result = await (0, import_js.copyAssets)({
+    assets,
+    watch: false,
+    outputPath
+  }, {
+    root: config.workspaceRoot,
+    targetName: "build",
+    target: buildTarget,
+    projectName,
+    projectGraph,
+    projectsConfigurations,
+    nxJsonConfiguration: nxJson,
+    cwd: config.workspaceRoot,
+    isVerbose: isVerbose(config.logLevel)
+  });
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  if (includeSrc === true) {
+    writeDebug(`\u{1F4DD}  Adding banner and writing source files: ${joinPaths(outputPath, "src")}`, config);
+    const files = await (0, import_glob.glob)([
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.ts"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.tsx"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.js"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(files.map(async (file) => import_node2.hfs.write(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await import_node2.hfs.text(file)}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+var import_node3 = require("@humanfs/node");
+var import_buildable_libs_utils = require("@nx/js/src/utils/buildable-libs-utils");
+var import_glob2 = require("glob");
+var import_project_graph = require("nx/src/project-graph/project-graph");
+var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectGraph = await (0, import_project_graph.createProjectGraphAsync)({
+    exitOnError: true
+  });
+  const projectConfigurations = (0, import_project_graph.readProjectsConfigurationFromProjectGraph)(projectGraph);
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const projectJsonPath = joinPaths(workspaceRoot, projectRoot, "project.json");
+  if (!await import_node3.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const projectDependencies = (0, import_buildable_libs_utils.calculateProjectBuildableDependencies)(void 0, projectGraph, workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = [];
+  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== projectRoot && dep.node.data.root !== workspaceRoot)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = joinPaths(workspaceRoot, projectNode.data.root, "package.json");
+      if (await import_node3.hfs.isFile(projectPackageJsonPath)) {
+        const projectPackageJson = await import_node3.hfs.json(projectPackageJsonPath);
+        if (projectPackageJson.private !== false) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    writeTrace(`\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, packageJson.peerDependenciesMeta ?? {});
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, packageJson.peerDependencies ?? {});
+  } else {
+    writeTrace("\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (config, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot = config.workspaceRoot ? config.workspaceRoot : findWorkspaceRoot();
+  const workspacePackageJson = await import_node3.hfs.json(joinPaths(workspaceRoot, "package.json"));
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!packageJson.contributors && packageJson.author) {
+    packageJson.contributors = [
+      packageJson.author
+    ];
+  }
+  packageJson.repository ??= workspacePackageJson.repository;
+  packageJson.repository.directory ??= projectRoot ? projectRoot : joinPaths("packages", projectName);
+  return packageJson;
+}, "addWorkspacePackageJsonFields");
+var addPackageJsonExport = /* @__PURE__ */ __name((file, type = "module", sourceRoot) => {
+  let entry = file.replaceAll("\\", "/");
+  if (sourceRoot) {
+    entry = entry.replace(sourceRoot, "");
+  }
+  return {
+    "import": {
+      "types": `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
+      "default": `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
+    },
+    "require": {
+      "types": `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
+      "default": `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
+    },
+    "default": {
+      "types": `./dist/${entry}.d.ts`,
+      "default": `./dist/${entry}.js`
+    }
+  };
+}, "addPackageJsonExport");
+var addPackageJsonExports = /* @__PURE__ */ __name(async (sourceRoot, packageJson) => {
+  packageJson.exports ??= {};
+  const files = await new import_glob2.Glob("**/*.{ts,tsx}", {
+    absolute: false,
+    cwd: sourceRoot,
+    root: sourceRoot
+  }).walk();
+  files.forEach((file) => {
+    addPackageJsonExport(file, packageJson.type, sourceRoot);
+    const split = file.split(".");
+    split.pop();
+    const entry = split.join(".").replaceAll("\\", "/");
+    packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, sourceRoot);
+  });
+  packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+  packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  packageJson.exports ??= {};
+  packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+    if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+      ret[key.replace("/index", "")] = packageJson.exports[key];
+    }
+    return ret;
+  }, packageJson.exports);
+  packageJson.exports["./package.json"] ??= "./package.json";
+  packageJson.exports["."] = packageJson.exports["."] ?? addPackageJsonExport("index", packageJson.type, sourceRoot);
+  return packageJson;
+}, "addPackageJsonExports");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+var import_glob3 = require("glob");
+
+// ../build-tools/src/utilities/task-graph.ts
+var import_create_task_graph = require("nx/src/tasks-runner/create-task-graph");
+
+// src/build.ts
+var import_defu3 = __toESM(require("defu"), 1);
+var import_node_path6 = require("path");
+var import_find_workspace_root5 = require("nx/src/utils/find-workspace-root");
 var import_unbuild = require("unbuild");
 
 // src/clean.ts
-var import_node = require("@humanfs/node");
-var import_console = require("@storm-software/config-tools/logger/console");
+var import_node4 = require("@humanfs/node");
 async function clean(name = "Unbuild", directory, config) {
-  (0, import_console.writeDebug)(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
-  const stopwatch = (0, import_console.getStopwatch)(`${name} output clean`);
-  await import_node.hfs.deleteAll(directory);
+  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = getStopwatch(`${name} output clean`);
+  await import_node4.hfs.deleteAll(directory);
   stopwatch();
 }
 __name(clean, "clean");
 
 // src/plugins/analyze.ts
-var import_config_tools = require("@storm-software/config-tools");
 var formatBytes = /* @__PURE__ */ __name((bytes) => {
   if (bytes === 0) return "0 Byte";
   const k = 1e3;
@@ -78,18 +1382,17 @@ var analyzePlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
     renderChunk(source, chunk) {
       const sourceBytes = formatBytes(source.length);
       const fileName = chunk.fileName;
-      (0, import_config_tools.writeInfo)(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+      writeInfo(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
     }
   };
 }, "analyzePlugin");
 
 // src/plugins/on-error.ts
-var import_config_tools2 = require("@storm-software/config-tools");
 var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:on-error",
   buildEnd(error) {
     if (error) {
-      (0, import_config_tools2.writeError)(`The following errors occurred during the build:
+      writeError(`The following errors occurred during the build:
 ${error ? error.message : "Unknown build error"}
 
     `, resolvedOptions.config);
@@ -97,7 +1400,7 @@ ${error ? error.message : "Unknown build error"}
     }
   },
   renderError(error) {
-    (0, import_config_tools2.writeError)(`The following errors occurred during the build:
+    writeError(`The following errors occurred during the build:
 ${error ? error.message : "Unknown build error"}
 
   `, resolvedOptions.config);
@@ -107,11 +1410,11 @@ ${error ? error.message : "Unknown build error"}
 
 // src/plugins/swc.ts
 var swcPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
-  const { transform } = require("@swc/core");
+  const { transform: transform2 } = require("@swc/core");
   return {
     name: "storm:swc",
     transform(code, filename) {
-      return transform(code, {
+      return transform2(code, {
         filename,
         jsc: {
           transform: {
@@ -126,44 +1429,43 @@ var swcPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
 }, "swcPlugin");
 
 // src/plugins/tsc.ts
-var import_devkit2 = require("@nx/devkit");
-var import_buildable_libs_utils2 = require("@nx/js/src/utils/buildable-libs-utils");
+var import_devkit5 = require("@nx/devkit");
+var import_buildable_libs_utils3 = require("@nx/js/src/utils/buildable-libs-utils");
 var import_compiler_helper_dependency = require("@nx/js/src/utils/compiler-helper-dependency");
 var import_rollup_plugin_typescript2 = __toESM(require("rollup-plugin-typescript2"), 1);
 
 // src/utilities/helpers.ts
-var import_devkit = require("@nx/devkit");
-var import_buildable_libs_utils = require("@nx/js/src/utils/buildable-libs-utils");
-var import_console2 = require("@storm-software/config-tools/logger/console");
-var import_node_path = require("path");
+var import_devkit4 = require("@nx/devkit");
+var import_buildable_libs_utils2 = require("@nx/js/src/utils/buildable-libs-utils");
+var import_node_path4 = require("path");
 var import_node_url = require("url");
 var import_typescript = __toESM(require("typescript"), 1);
-async function loadConfig(configPath) {
-  if (!/\.(js|mjs)$/.test((0, import_node_path.extname)(configPath))) {
+async function loadConfig2(configPath) {
+  if (!/\.(js|mjs)$/.test((0, import_node_path4.extname)(configPath))) {
     throw new Error("Unsupported config file format");
   }
   return import((0, import_node_url.pathToFileURL)(configPath).toString()).then((config) => config.default);
 }
-__name(loadConfig, "loadConfig");
+__name(loadConfig2, "loadConfig");
 async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
-  const tsConfigFile = import_typescript.default.readConfigFile((0, import_devkit.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath), import_typescript.default.sys.readFile);
-  const tsConfig = import_typescript.default.parseJsonConfigFileContent(tsConfigFile.config, import_typescript.default.sys, (0, import_node_path.dirname)((0, import_devkit.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath)));
+  const tsConfigFile = import_typescript.default.readConfigFile((0, import_devkit4.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath), import_typescript.default.sys.readFile);
+  const tsConfig = import_typescript.default.parseJsonConfigFileContent(tsConfigFile.config, import_typescript.default.sys, (0, import_node_path4.dirname)((0, import_devkit4.joinPathFragments)(config.workspaceRoot, projectRoot, tsConfigPath)));
   const compilerOptions = {
     rootDir: projectRoot,
     declaration: true,
-    paths: (0, import_buildable_libs_utils.computeCompilerOptionsPaths)(tsConfig, dependencies ?? [])
+    paths: (0, import_buildable_libs_utils2.computeCompilerOptionsPaths)(tsConfig, dependencies ?? [])
   };
-  (0, import_console2.writeTrace)(compilerOptions, config);
+  writeTrace(compilerOptions, config);
   return compilerOptions;
 }
 __name(createTsCompilerOptions, "createTsCompilerOptions");
 
 // src/plugins/tsc.ts
 var tscPlugin = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
-  const projectGraph = await (0, import_devkit2.createProjectGraphAsync)({
+  const projectGraph = await (0, import_devkit5.createProjectGraphAsync)({
     exitOnError: true
   });
-  const result = (0, import_buildable_libs_utils2.calculateProjectBuildableDependencies)(void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const result = (0, import_buildable_libs_utils3.calculateProjectBuildableDependencies)(void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
   let dependencies = result.dependencies;
   const tsLibDependency = (0, import_compiler_helper_dependency.getHelperDependency)(import_compiler_helper_dependency.HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
   if (tsLibDependency) {
@@ -180,7 +1482,7 @@ var tscPlugin = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
 }, "tscPlugin");
 
 // src/plugins/type-definitions.ts
-var import_node_path2 = require("path");
+var import_node_path5 = require("path");
 var typeDefinitions = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:dts-bundle",
   async generateBundle(_opts, bundle) {
@@ -189,7 +1491,7 @@ var typeDefinitions = /* @__PURE__ */ __name((options, resolvedOptions) => ({
         continue;
       }
       const hasDefaultExport = file.exports.includes("default");
-      const entrySourceFileName = (0, import_node_path2.relative)(options.projectRoot, file.facadeModuleId);
+      const entrySourceFileName = (0, import_node_path5.relative)(options.projectRoot, file.facadeModuleId);
       const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
       const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
       const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
@@ -222,55 +1524,55 @@ async function resolveOptions(options) {
   if (!projectRoot) {
     throw new Error("Cannot find project root");
   }
-  const outputPath = options.outputPath || (0, import_correct_paths.joinPaths)("dist", projectRoot);
-  const workspaceRoot = (0, import_find_workspace_root.findWorkspaceRoot)(projectRoot);
+  const outputPath = options.outputPath || joinPaths("dist", projectRoot);
+  const workspaceRoot = (0, import_find_workspace_root5.findWorkspaceRoot)(projectRoot);
   if (!workspaceRoot) {
     throw new Error("Cannot find workspace root");
   }
-  const config = await (0, import_create_storm_config.loadStormConfig)(workspaceRoot.dir);
-  (0, import_console3.writeDebug)("  \u2699\uFE0F   Resolving build options", config);
-  const stopwatch = (0, import_console3.getStopwatch)("Build options resolution");
+  const config = await loadStormConfig(workspaceRoot.dir);
+  writeDebug("  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = getStopwatch("Build options resolution");
   if (options.configPath) {
-    const configFile = await loadConfig(options.configPath);
+    const configFile = await loadConfig2(options.configPath);
     if (configFile) {
-      options = (0, import_defu.default)(options, configFile);
+      options = (0, import_defu3.default)(options, configFile);
     }
   }
-  const projectGraph = await (0, import_devkit3.createProjectGraphAsync)({
+  const projectGraph = await (0, import_devkit6.createProjectGraphAsync)({
     exitOnError: true
   });
-  const projectJsonPath = (0, import_correct_paths.joinPaths)(config.workspaceRoot, projectRoot, "project.json");
-  if (!await import_node2.hfs.isFile(projectJsonPath)) {
+  const projectJsonPath = joinPaths(config.workspaceRoot, projectRoot, "project.json");
+  if (!await import_node5.hfs.isFile(projectJsonPath)) {
     throw new Error("Cannot find project.json configuration");
   }
-  const projectJson = await import_node2.hfs.json(projectJsonPath);
+  const projectJson = await import_node5.hfs.json(projectJsonPath);
   const projectName = projectJson.name;
-  const packageJsonPath = (0, import_correct_paths.joinPaths)(workspaceRoot.dir, projectRoot, "package.json");
-  if (!await import_node2.hfs.isFile(packageJsonPath)) {
+  const packageJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "package.json");
+  if (!await import_node5.hfs.isFile(packageJsonPath)) {
     throw new Error("Cannot find package.json configuration");
   }
-  const packageJson = await import_node2.hfs.json(packageJsonPath);
+  const packageJson = await import_node5.hfs.json(packageJsonPath);
   let tsconfig = options.tsconfig;
   if (!tsconfig) {
-    tsconfig = (0, import_correct_paths.joinPaths)(workspaceRoot.dir, projectRoot, "tsconfig.json");
+    tsconfig = joinPaths(workspaceRoot.dir, projectRoot, "tsconfig.json");
   }
-  if (!await import_node2.hfs.isFile(tsconfig)) {
+  if (!await import_node5.hfs.isFile(tsconfig)) {
     throw new Error("Cannot find tsconfig.json configuration");
   }
   let sourceRoot = projectJson.sourceRoot;
   if (!sourceRoot) {
-    sourceRoot = (0, import_correct_paths.joinPaths)(projectRoot, "src");
+    sourceRoot = joinPaths(projectRoot, "src");
   }
-  if (!await import_node2.hfs.isDirectory(sourceRoot)) {
+  if (!await import_node5.hfs.isDirectory(sourceRoot)) {
     throw new Error("Cannot find sourceRoot directory");
   }
-  const projectConfigurations = (0, import_devkit3.readProjectsConfigurationFromProjectGraph)(projectGraph);
+  const projectConfigurations = (0, import_devkit6.readProjectsConfigurationFromProjectGraph)(projectGraph);
   if (!projectConfigurations?.projects?.[projectName]) {
     throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
   }
-  const result = (0, import_buildable_libs_utils3.calculateProjectBuildableDependencies)(void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const result = (0, import_buildable_libs_utils4.calculateProjectBuildableDependencies)(void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
   let dependencies = result.dependencies;
-  const tsLibDependency = (0, import_js.getHelperDependency)(import_js.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  const tsLibDependency = (0, import_js2.getHelperDependency)(import_js2.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
   if (tsLibDependency) {
     dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
     dependencies.push(tsLibDependency);
@@ -287,14 +1589,14 @@ async function resolveOptions(options) {
       {
         builder: "mkdist",
         input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: (0, import_correct_paths.joinPaths)((0, import_node_path3.relative)((0, import_correct_paths.joinPaths)(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        outDir: joinPaths((0, import_node_path6.relative)(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
         declaration: options.emitTypes !== false,
         format: "esm"
       },
       {
         builder: "mkdist",
         input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: (0, import_correct_paths.joinPaths)((0, import_node_path3.relative)((0, import_correct_paths.joinPaths)(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        outDir: joinPaths((0, import_node_path6.relative)(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
         declaration: options.emitTypes !== false,
         format: "cjs",
         ext: "cjs"
@@ -352,7 +1654,7 @@ async function resolveOptions(options) {
         splitting: options.splitting !== false,
         treeShaking: options.treeShaking !== false,
         color: true,
-        logLevel: config.logLevel === import_types.LogLevelLabel.FATAL ? import_types.LogLevelLabel.ERROR : (0, import_get_log_level.isVerbose)() ? "verbose" : config.logLevel
+        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "verbose" : config.logLevel
       }
     }
   };
@@ -369,14 +1671,14 @@ async function resolveOptions(options) {
   if (options.rollup) {
     let rollup = {};
     if (typeof options.rollup === "string") {
-      const rollupFile = await loadConfig(options.rollup);
+      const rollupFile = await loadConfig2(options.rollup);
       if (rollupFile) {
         rollup = rollupFile;
       }
     } else {
       rollup = options.rollup;
     }
-    resolvedOptions.rollup = (0, import_defu.default)(resolvedOptions.rollup ?? {}, rollup);
+    resolvedOptions.rollup = (0, import_defu3.default)(resolvedOptions.rollup ?? {}, rollup);
   }
   resolvedOptions.hooks = {
     "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
@@ -388,29 +1690,29 @@ async function resolveOptions(options) {
 }
 __name(resolveOptions, "resolveOptions");
 async function generatePackageJson(options) {
-  if (options.generatePackageJson !== false && await import_node2.hfs.isFile((0, import_correct_paths.joinPaths)(options.projectRoot, "package.json"))) {
-    (0, import_console3.writeDebug)("  \u270D\uFE0F   Writing package.json file", options.config);
-    const stopwatch = (0, import_console3.getStopwatch)("Write package.json file");
-    const packageJsonPath = (0, import_correct_paths.joinPaths)(options.projectRoot, "project.json");
-    if (!await import_node2.hfs.isFile(packageJsonPath)) {
+  if (options.generatePackageJson !== false && await import_node5.hfs.isFile(joinPaths(options.projectRoot, "package.json"))) {
+    writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = getStopwatch("Write package.json file");
+    const packageJsonPath = joinPaths(options.projectRoot, "project.json");
+    if (!await import_node5.hfs.isFile(packageJsonPath)) {
       throw new Error("Cannot find package.json configuration");
     }
-    let packageJson = await import_node2.hfs.json((0, import_correct_paths.joinPaths)(options.config.workspaceRoot, options.projectRoot, "package.json"));
+    let packageJson = await import_node5.hfs.json(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"));
     if (!packageJson) {
       throw new Error("Cannot find package.json configuration file");
     }
-    packageJson = await (0, import_build_tools.addPackageDependencies)(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
-    packageJson = await (0, import_build_tools.addWorkspacePackageJsonFields)(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
-    packageJson = await (0, import_build_tools.addPackageJsonExports)(options.sourceRoot, packageJson);
-    await (0, import_devkit3.writeJsonFile)((0, import_correct_paths.joinPaths)(options.outDir, "package.json"), packageJson);
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson = await addPackageJsonExports(options.sourceRoot, packageJson);
+    await (0, import_devkit6.writeJsonFile)(joinPaths(options.outDir, "package.json"), packageJson);
     stopwatch();
   }
   return options;
 }
 __name(generatePackageJson, "generatePackageJson");
 async function executeUnbuild(options) {
-  (0, import_console3.writeDebug)(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
-  const stopwatch = (0, import_console3.getStopwatch)(`${options.name} (${options.projectRoot}) build`);
+  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
   try {
     await (0, import_unbuild.build)(options.projectRoot, false, {
       ...options,
@@ -423,9 +1725,9 @@ async function executeUnbuild(options) {
 }
 __name(executeUnbuild, "executeUnbuild");
 async function copyBuildAssets(options) {
-  (0, import_console3.writeDebug)(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
-  const stopwatch = (0, import_console3.getStopwatch)(`${options.name} asset copy`);
-  await (0, import_build_tools.copyAssets)(options.config, options.assets ?? [], options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
+  const stopwatch = getStopwatch(`${options.name} asset copy`);
+  await copyAssets(options.config, options.assets ?? [], options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
   stopwatch();
   return options;
 }
@@ -438,17 +1740,17 @@ async function cleanOutputPath(options) {
 }
 __name(cleanOutputPath, "cleanOutputPath");
 async function build(options) {
-  (0, import_console3.writeDebug)(` \u26A1  Executing Storm Unbuild pipeline`);
-  const stopwatch = (0, import_console3.getStopwatch)("Unbuild pipeline");
+  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`);
+  const stopwatch = getStopwatch("Unbuild pipeline");
   try {
     const resolvedOptions = await resolveOptions(options);
     await cleanOutputPath(resolvedOptions);
     await generatePackageJson(resolvedOptions);
     await executeUnbuild(resolvedOptions);
     await copyBuildAssets(resolvedOptions);
-    (0, import_console3.writeSuccess)(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
+    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
   } catch (error) {
-    (0, import_console3.writeFatal)("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
     throw error;
   } finally {
     stopwatch();
@@ -459,8 +1761,8 @@ __name(build, "build");
 // bin/unbuild.ts
 async function createProgram(config) {
   try {
-    (0, import_console4.writeInfo)("\u26A1 Running Storm Unbuild pipeline", config);
-    const root = (0, import_find_workspace_root2.findWorkspaceRootSafe)();
+    writeInfo("\u26A1 Running Storm Unbuild pipeline", config);
+    const root = findWorkspaceRootSafe();
     process.env.STORM_WORKSPACE_ROOT ??= root;
     process.env.NX_WORKSPACE_ROOT_PATH ??= root;
     root && process.chdir(root);
@@ -525,7 +1827,7 @@ async function createProgram(config) {
     program.command("clean").alias("clear").description("Clean the output directory of the project. This command will remove the 'dist' folder.").addOption(nameOption).action(cleanAction(config));
     return program;
   } catch (e) {
-    (0, import_console4.writeFatal)(`A fatal error occurred while running the program: ${e.message}`, config);
+    writeFatal(`A fatal error occurred while running the program: ${e.message}`, config);
     process.exit(1);
   }
 }
@@ -572,8 +1874,8 @@ var buildAction = /* @__PURE__ */ __name((config) => async (options) => {
       }
     });
   } catch (e) {
-    (0, import_console4.writeFatal)(`A fatal error occurred while cleaning the Unbuild output directory: ${e.message}`, config);
-    (0, import_process_handler.exitWithError)(config);
+    writeFatal(`A fatal error occurred while cleaning the Unbuild output directory: ${e.message}`, config);
+    exitWithError(config);
     process.exit(1);
   }
 }, "buildAction");
@@ -581,25 +1883,25 @@ var cleanAction = /* @__PURE__ */ __name((config) => async (options) => {
   try {
     await clean(options.name, options.output, config);
   } catch (e) {
-    (0, import_console4.writeFatal)(`A fatal error occurred while cleaning the ESBuild output directory: ${e.message}`, config);
-    (0, import_process_handler.exitWithError)(config);
+    writeFatal(`A fatal error occurred while cleaning the ESBuild output directory: ${e.message}`, config);
+    exitWithError(config);
     process.exit(1);
   }
 }, "cleanAction");
 void (async () => {
-  const config = await (0, import_create_storm_config2.loadStormConfig)();
-  const stopwatch = (0, import_console4.getStopwatch)("Storm ESBuild executable");
+  const config = await loadStormConfig();
+  const stopwatch = getStopwatch("Storm ESBuild executable");
   try {
-    (0, import_process_handler.handleProcess)(config);
+    handleProcess(config);
     const program = await createProgram(config);
     await program.parseAsync(process.argv);
-    (0, import_console4.writeSuccess)(`\u{1F389}  Storm ESBuild executable has completed successfully!`, config);
-    (0, import_process_handler.exitWithSuccess)(config);
+    writeSuccess(`\u{1F389}  Storm ESBuild executable has completed successfully!`, config);
+    exitWithSuccess(config);
   } catch (error) {
-    (0, import_console4.writeFatal)(`A fatal error occurred while running Storm ESBuild executable: 
+    writeFatal(`A fatal error occurred while running Storm ESBuild executable: 
 
 ${error.message}`, config);
-    (0, import_process_handler.exitWithError)(config);
+    exitWithError(config);
     process.exit(1);
   } finally {
     stopwatch();