@storm-software/unbuild 0.25.2 → 0.26.0

package/dist/chunk-DRQUQQ5D.js

@@ -0,0 +1,2459 @@
+import {
+  cleanDirectories
+} from "./chunk-JIVM7FQJ.js";
+import {
+  getDefaultBuildPlugins
+} from "./chunk-TFMXUACY.js";
+import {
+  loadConfig
+} from "./chunk-VEX5RCZW.js";
+import {
+  COLOR_KEYS,
+  LogLevel,
+  LogLevelLabel,
+  STORM_DEFAULT_DOCS,
+  STORM_DEFAULT_HOMEPAGE,
+  STORM_DEFAULT_LICENSING,
+  correctPaths,
+  findWorkspaceRoot,
+  formatLogMessage,
+  getDefaultConfig,
+  getLogLevel,
+  getLogLevelLabel,
+  getStopwatch,
+  isVerbose,
+  joinPaths,
+  writeDebug,
+  writeFatal,
+  writeSuccess,
+  writeSystem,
+  writeTrace,
+  writeWarning
+} from "./chunk-BRHZNXQM.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/build.ts
+import { readCachedProjectGraph as readCachedProjectGraph3, writeJsonFile } from "@nx/devkit";
+import { getHelperDependency, HelperDependency } from "@nx/js";
+import { calculateProjectBuildableDependencies as calculateProjectBuildableDependencies2 } from "@nx/js/src/utils/buildable-libs-utils";
+
+// ../build-tools/src/plugins/swc.ts
+import { transform } from "@swc/core";
+
+// ../build-tools/src/plugins/ts-resolve.ts
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import path from "node:path";
+import _resolve from "resolve";
+
+// ../build-tools/src/plugins/type-definitions.ts
+import { stripIndents } from "@nx/devkit";
+import { relative } from "path";
+
+// ../build-tools/src/utilities/copy-assets.ts
+import { readCachedProjectGraph, readProjectsConfigurationFromProjectGraph } from "@nx/devkit";
+import { copyAssets as copyAssetsBase } from "@nx/js";
+import { glob } from "glob";
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+
+// ../config-tools/src/config-file/get-config-file.ts
+import { loadConfig as loadConfig2 } from "c12";
+import defu from "defu";
+var getConfigFileByName = /* @__PURE__ */ __name(async (fileName, filePath, options = {}) => {
+  const workspacePath = filePath || findWorkspaceRoot(filePath);
+  let config = await loadConfig2({
+    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
+  });
+  if (!config || Object.keys(config).length === 0) {
+    config = await loadConfig2({
+      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 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 = defu(result2.config ?? {}, config ?? {});
+      }
+    }
+  }
+  if (!config) {
+    return void 0;
+  }
+  config.configFile = configFile;
+  return config;
+}, "getConfigFile");
+
+// ../config-tools/src/create-storm-config.ts
+import defu2 from "defu";
+
+// ../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 = defu2(getConfigEnv(), configFile, getDefaultConfig(_workspaceRoot));
+  setConfigEnv(config);
+  writeTrace(`\u2699\uFE0F  Using Storm configuration: 
+${formatLogMessage(config)}`, config);
+  return config;
+}, "loadStormConfig");
+
+// ../build-tools/src/utilities/read-nx-config.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+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 (!existsSync(nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const configContent = await readFile(nxJsonPath, "utf8");
+  return JSON.parse(configContent);
+}, "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 = readCachedProjectGraph();
+  const projectsConfigurations = 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 copyAssetsBase({
+    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 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) => writeFile(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await readFile2(file, "utf8")}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { Glob } from "glob";
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { readCachedProjectGraph as readCachedProjectGraph2 } from "nx/src/project-graph/project-graph";
+var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectDependencies = calculateProjectBuildableDependencies(void 0, readCachedProjectGraph2(), 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 (existsSync2(projectPackageJsonPath)) {
+        const projectPackageJsonContent = await readFile3(projectPackageJsonPath, "utf8");
+        const projectPackageJson = JSON.parse(projectPackageJsonContent);
+        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 workspacePackageJsonContent = await readFile3(joinPaths(workspaceRoot, "package.json"), "utf8");
+  const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
+  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 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
+import { glob as glob2 } from "glob";
+
+// ../build-tools/src/utilities/task-graph.ts
+import { createTaskGraph, mapTargetDefaultsToDependencies } from "nx/src/tasks-runner/create-task-graph";
+
+// src/build.ts
+import defu4 from "defu";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { relative as relative3 } from "node:path";
+import { findWorkspaceRoot as findWorkspaceRoot2 } from "nx/src/utils/find-workspace-root";
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/shared/unbuild.B2_7OVir.mjs
+import Module from "node:module";
+import { existsSync as existsSync3, readdirSync, statSync, promises } from "node:fs";
+import { join, resolve, normalize, dirname, relative as relative2, extname, isAbsolute } from "pathe";
+import { colors } from "consola/utils";
+import consola$1, { consola } from "consola";
+import { defu as defu3 } from "defu";
+import { createHooks } from "hookable";
+import prettyBytes from "pretty-bytes";
+import { glob as glob3 } from "tinyglobby";
+import fsp, { mkdir, writeFile as writeFile2 } from "node:fs/promises";
+import { createJiti } from "jiti";
+import { watch, rollup } from "rollup";
+import dts from "rollup-plugin-dts";
+import commonjs from "@rollup/plugin-commonjs";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import alias from "@rollup/plugin-alias";
+import replace from "@rollup/plugin-replace";
+import { resolveAlias } from "pathe/utils";
+import { findStaticImports, parseNodeModulePath, fileURLToPath, resolvePath, resolveModuleExportNames } from "mlly";
+import { transform as transform2 } from "esbuild";
+import { createFilter } from "@rollup/pluginutils";
+import rollupJSONPlugin from "@rollup/plugin-json";
+import MagicString from "magic-string";
+import { resolveSchema, generateMarkdown, generateTypes } from "untyped";
+import untypedPlugin from "untyped/babel-plugin";
+import { pascalCase } from "scule";
+import { mkdist } from "mkdist";
+function definePreset(preset) {
+  return preset;
+}
+__name(definePreset, "definePreset");
+var autoPreset = definePreset(() => {
+  return {
+    hooks: {
+      "build:prepare"(ctx) {
+        if (!ctx.pkg || ctx.options.entries.length > 0) {
+          return;
+        }
+        const sourceFiles = listRecursively(join(ctx.options.rootDir, "src"));
+        const res = inferEntries(ctx.pkg, sourceFiles, ctx.options.rootDir);
+        for (const message of res.warnings) {
+          warn(ctx, message);
+        }
+        ctx.options.entries.push(...res.entries);
+        if (res.cjs) {
+          ctx.options.rollup.emitCJS = true;
+        }
+        if (ctx.options.declaration === void 0) {
+          ctx.options.declaration = res.dts ? "compatible" : false;
+        }
+        consola.info(
+          "Automatically detected entries:",
+          colors.cyan(
+            ctx.options.entries.map(
+              (e) => colors.bold(
+                e.input.replace(ctx.options.rootDir + "/", "").replace(/\/$/, "/*")
+              )
+            ).join(", ")
+          ),
+          colors.gray(
+            ["esm", res.cjs && "cjs", res.dts && "dts"].filter(Boolean).map((tag) => `[${tag}]`).join(" ")
+          )
+        );
+      }
+    }
+  };
+});
+function inferEntries(pkg, sourceFiles, rootDir) {
+  const warnings = [];
+  sourceFiles.sort((a, b) => a.split("/").length - b.split("/").length);
+  const outputs = extractExportFilenames(pkg.exports);
+  if (pkg.bin) {
+    const binaries = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
+    for (const file of binaries) {
+      outputs.push({ file });
+    }
+  }
+  if (pkg.main) {
+    outputs.push({ file: pkg.main });
+  }
+  if (pkg.module) {
+    outputs.push({ type: "esm", file: pkg.module });
+  }
+  if (pkg.types || pkg.typings) {
+    outputs.push({ file: pkg.types || pkg.typings });
+  }
+  const isESMPkg = pkg.type === "module";
+  for (const output of outputs.filter((o) => !o.type)) {
+    const isJS = output.file.endsWith(".js");
+    if (isESMPkg && isJS || output.file.endsWith(".mjs")) {
+      output.type = "esm";
+    } else if (!isESMPkg && isJS || output.file.endsWith(".cjs")) {
+      output.type = "cjs";
+    }
+  }
+  let cjs = false;
+  let dts2 = false;
+  const entries = [];
+  for (const output of outputs) {
+    const outputSlug = output.file.replace(
+      /(\*[^/\\]*|\.d\.(m|c)?ts|\.\w+)$/,
+      ""
+    );
+    const isDir = outputSlug.endsWith("/");
+    if (isDir && ["./", "/"].includes(outputSlug)) {
+      continue;
+    }
+    const possiblePaths = getEntrypointPaths(outputSlug);
+    const input = possiblePaths.reduce((source, d) => {
+      if (source) {
+        return source;
+      }
+      const SOURCE_RE = new RegExp(
+        `(?<=/|$)${d}${isDir ? "" : String.raw`\.\w+`}$`
+      );
+      return sourceFiles.find((i) => SOURCE_RE.test(i))?.replace(/(\.d\.(m|c)?ts|\.\w+)$/, "");
+    }, void 0);
+    if (!input) {
+      if (!existsSync3(resolve(rootDir || ".", output.file))) {
+        warnings.push(`Could not find entrypoint for \`${output.file}\``);
+      }
+      continue;
+    }
+    if (output.type === "cjs") {
+      cjs = true;
+    }
+    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input }) - 1];
+    if (/\.d\.(m|c)?ts$/.test(output.file)) {
+      dts2 = true;
+    }
+    if (isDir) {
+      entry.outDir = outputSlug;
+      entry.format = output.type;
+    }
+  }
+  return { entries, cjs, dts: dts2, warnings };
+}
+__name(inferEntries, "inferEntries");
+var getEntrypointPaths = /* @__PURE__ */ __name((path2) => {
+  const segments = normalize(path2).split("/");
+  return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
+}, "getEntrypointPaths");
+async function ensuredir(path2) {
+  await fsp.mkdir(dirname(path2), { recursive: true });
+}
+__name(ensuredir, "ensuredir");
+function warn(ctx, message) {
+  if (ctx.warnings.has(message)) {
+    return;
+  }
+  consola.debug("[unbuild] [warn]", message);
+  ctx.warnings.add(message);
+}
+__name(warn, "warn");
+async function symlink(from, to, force = true) {
+  await ensuredir(to);
+  if (force) {
+    await fsp.unlink(to).catch(() => {
+    });
+  }
+  await fsp.symlink(from, to, "junction");
+}
+__name(symlink, "symlink");
+function dumpObject(obj) {
+  return "{ " + Object.keys(obj).map((key) => `${key}: ${JSON.stringify(obj[key])}`).join(", ") + " }";
+}
+__name(dumpObject, "dumpObject");
+function getpkg(id = "") {
+  const s = id.split("/");
+  return s[0][0] === "@" ? `${s[0]}/${s[1]}` : s[0];
+}
+__name(getpkg, "getpkg");
+async function rmdir(dir) {
+  await fsp.unlink(dir).catch(() => {
+  });
+  await fsp.rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+}
+__name(rmdir, "rmdir");
+function listRecursively(path2) {
+  const filenames = /* @__PURE__ */ new Set();
+  const walk = /* @__PURE__ */ __name((path22) => {
+    const files = readdirSync(path22);
+    for (const file of files) {
+      const fullPath = resolve(path22, file);
+      if (statSync(fullPath).isDirectory()) {
+        filenames.add(fullPath + "/");
+        walk(fullPath);
+      } else {
+        filenames.add(fullPath);
+      }
+    }
+  }, "walk");
+  walk(path2);
+  return [...filenames];
+}
+__name(listRecursively, "listRecursively");
+async function resolvePreset(preset, rootDir) {
+  if (preset === "auto") {
+    preset = autoPreset;
+  } else if (typeof preset === "string") {
+    preset = await createJiti(rootDir, { interopDefault: true }).import(preset, {
+      default: true
+    }) || {};
+  }
+  if (typeof preset === "function") {
+    preset = preset();
+  }
+  return preset;
+}
+__name(resolvePreset, "resolvePreset");
+function inferExportType(condition, previousConditions = [], filename = "") {
+  if (filename) {
+    if (filename.endsWith(".d.ts")) {
+      return "esm";
+    }
+    if (filename.endsWith(".mjs")) {
+      return "esm";
+    }
+    if (filename.endsWith(".cjs")) {
+      return "cjs";
+    }
+  }
+  switch (condition) {
+    case "import": {
+      return "esm";
+    }
+    case "require": {
+      return "cjs";
+    }
+    default: {
+      if (previousConditions.length === 0) {
+        return "esm";
+      }
+      const [newCondition, ...rest] = previousConditions;
+      return inferExportType(newCondition, rest, filename);
+    }
+  }
+}
+__name(inferExportType, "inferExportType");
+function extractExportFilenames(exports, conditions = []) {
+  if (!exports) {
+    return [];
+  }
+  if (typeof exports === "string") {
+    return [{ file: exports, type: "esm" }];
+  }
+  return Object.entries(exports).filter(([subpath]) => !subpath.endsWith(".json")).flatMap(
+    ([condition, exports2]) => typeof exports2 === "string" ? {
+      file: exports2,
+      type: inferExportType(condition, conditions, exports2)
+    } : extractExportFilenames(exports2, [...conditions, condition])
+  );
+}
+__name(extractExportFilenames, "extractExportFilenames");
+function arrayIncludes(arr, searchElement) {
+  return arr.some(
+    (entry) => entry instanceof RegExp ? entry.test(searchElement) : entry === searchElement
+  );
+}
+__name(arrayIncludes, "arrayIncludes");
+function removeExtension(filename) {
+  return filename.replace(/\.(js|mjs|cjs|ts|mts|cts|json|jsx|tsx)$/, "");
+}
+__name(removeExtension, "removeExtension");
+function inferPkgExternals(pkg) {
+  const externals = [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}).filter(
+      (dep) => dep.startsWith("@types/")
+    ),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ];
+  if (pkg.name) {
+    externals.push(pkg.name);
+    if (pkg.exports) {
+      for (const subpath of Object.keys(pkg.exports)) {
+        if (subpath.startsWith("./")) {
+          externals.push(pathToRegex(`${pkg.name}/${subpath.slice(2)}`));
+        }
+      }
+    }
+  }
+  if (pkg.imports) {
+    for (const importName of Object.keys(pkg.imports)) {
+      if (importName.startsWith("#")) {
+        externals.push(pathToRegex(importName));
+      }
+    }
+  }
+  return [...new Set(externals)];
+}
+__name(inferPkgExternals, "inferPkgExternals");
+function pathToRegex(path2) {
+  return path2.includes("*") ? new RegExp(
+    `^${path2.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`
+  ) : path2;
+}
+__name(pathToRegex, "pathToRegex");
+function withTrailingSlash(path2) {
+  return path2.endsWith("/") ? path2 : `${path2}/`;
+}
+__name(withTrailingSlash, "withTrailingSlash");
+function validateDependencies(ctx) {
+  const usedDependencies = /* @__PURE__ */ new Set();
+  const unusedDependencies = new Set(
+    Object.keys(ctx.pkg.dependencies || {})
+  );
+  const implicitDependencies = /* @__PURE__ */ new Set();
+  for (const id of ctx.usedImports) {
+    unusedDependencies.delete(id);
+    usedDependencies.add(id);
+  }
+  if (Array.isArray(ctx.options.dependencies)) {
+    for (const id of ctx.options.dependencies) {
+      unusedDependencies.delete(id);
+    }
+  }
+  for (const id of usedDependencies) {
+    if (!arrayIncludes(ctx.options.externals, id) && !id.startsWith("chunks/") && !ctx.options.dependencies.includes(getpkg(id)) && !ctx.options.peerDependencies.includes(getpkg(id))) {
+      implicitDependencies.add(id);
+    }
+  }
+  if (unusedDependencies.size > 0) {
+    warn(
+      ctx,
+      "Potential unused dependencies found: " + [...unusedDependencies].map((id) => colors.cyan(id)).join(", ")
+    );
+  }
+  if (implicitDependencies.size > 0 && !ctx.options.rollup.inlineDependencies) {
+    warn(
+      ctx,
+      "Potential implicit dependencies found: " + [...implicitDependencies].map((id) => colors.cyan(id)).join(", ")
+    );
+  }
+}
+__name(validateDependencies, "validateDependencies");
+function validatePackage(pkg, rootDir, ctx) {
+  if (!pkg) {
+    return;
+  }
+  const filenames = new Set(
+    [
+      ...typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin || {}),
+      pkg.main,
+      pkg.module,
+      pkg.types,
+      pkg.typings,
+      ...extractExportFilenames(pkg.exports).map((i) => i.file)
+    ].map((i) => i && resolve(rootDir, i.replace(/\/[^/]*\*.*$/, "")))
+  );
+  const missingOutputs = [];
+  for (const filename of filenames) {
+    if (filename && !filename.includes("*") && !existsSync3(filename)) {
+      missingOutputs.push(filename.replace(rootDir + "/", ""));
+    }
+  }
+  if (missingOutputs.length > 0) {
+    warn(
+      ctx,
+      `Potential missing package.json files: ${missingOutputs.map((o) => colors.cyan(o)).join(", ")}`
+    );
+  }
+}
+__name(validatePackage, "validatePackage");
+var SHEBANG_RE = /^#![^\n]*/;
+function shebangPlugin() {
+  return {
+    name: "unbuild-shebang",
+    async writeBundle(options, bundle) {
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") {
+          continue;
+        }
+        if (output.code?.match(SHEBANG_RE)) {
+          const outFile = resolve(options.dir, fileName);
+          await makeExecutable(outFile);
+        }
+      }
+    }
+  };
+}
+__name(shebangPlugin, "shebangPlugin");
+function removeShebangPlugin() {
+  return {
+    name: "unbuild-remove-shebang",
+    renderChunk(code) {
+      return code.replace(SHEBANG_RE, "");
+    }
+  };
+}
+__name(removeShebangPlugin, "removeShebangPlugin");
+async function makeExecutable(filePath) {
+  await promises.chmod(
+    filePath,
+    493
+    /* rwx r-x r-x */
+  ).catch(() => {
+  });
+}
+__name(makeExecutable, "makeExecutable");
+function getShebang(code, append = "\n") {
+  const m = code.match(SHEBANG_RE);
+  return m ? m + append : "";
+}
+__name(getShebang, "getShebang");
+var DefaultLoaders = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".jsx": "jsx"
+};
+function esbuild(options) {
+  const {
+    include = new RegExp(Object.keys(DefaultLoaders).join("|")),
+    exclude = /node_modules/,
+    loaders: loaderOptions,
+    ...esbuildOptions
+  } = options;
+  const loaders = { ...DefaultLoaders };
+  if (loaderOptions) {
+    for (const [key, value] of Object.entries(loaderOptions)) {
+      if (typeof value === "string") {
+        loaders[key] = value;
+      } else if (value === false) {
+        delete loaders[key];
+      }
+    }
+  }
+  const getLoader = /* @__PURE__ */ __name((id = "") => {
+    return loaders[extname(id)];
+  }, "getLoader");
+  const filter = createFilter(include, exclude);
+  return {
+    name: "esbuild",
+    async transform(code, id) {
+      if (!filter(id)) {
+        return null;
+      }
+      const loader = getLoader(id);
+      if (!loader) {
+        return null;
+      }
+      const result = await transform2(code, {
+        ...esbuildOptions,
+        loader,
+        sourcefile: id
+      });
+      printWarnings(id, result, this);
+      return {
+        code: result.code || "",
+        map: result.map || null
+      };
+    },
+    async renderChunk(code, { fileName }) {
+      if (!options.minify) {
+        return null;
+      }
+      if (/\.d\.(c|m)?tsx?$/.test(fileName)) {
+        return null;
+      }
+      const loader = getLoader(fileName);
+      if (!loader) {
+        return null;
+      }
+      const result = await transform2(code, {
+        ...esbuildOptions,
+        loader,
+        sourcefile: fileName,
+        minify: true
+      });
+      return {
+        code: result.code || "",
+        map: result.map || null
+      };
+    }
+  };
+}
+__name(esbuild, "esbuild");
+function printWarnings(id, result, plugin) {
+  if (result.warnings) {
+    for (const warning of result.warnings) {
+      let message = "[esbuild]";
+      if (warning.location) {
+        message += ` (${relative2(process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
+      }
+      message += ` ${warning.text}`;
+      plugin.warn(message);
+    }
+  }
+}
+__name(printWarnings, "printWarnings");
+var EXPORT_DEFAULT = "export default ";
+function JSONPlugin(options) {
+  const plugin = rollupJSONPlugin(options);
+  return {
+    ...plugin,
+    name: "unbuild-json",
+    transform(code, id) {
+      const res = plugin.transform.call(this, code, id);
+      if (res && typeof res !== "string" && "code" in res && res.code && res.code.startsWith(EXPORT_DEFAULT)) {
+        res.code = res.code.replace(EXPORT_DEFAULT, "module.exports = ");
+      }
+      return res;
+    }
+  };
+}
+__name(JSONPlugin, "JSONPlugin");
+var defaults = {
+  include: [/\.(md|txt|css|htm|html)$/],
+  exclude: []
+};
+function rawPlugin(opts = {}) {
+  opts = { ...opts, ...defaults };
+  const filter = createFilter(opts.include, opts.exclude);
+  return {
+    name: "unbuild-raw",
+    transform(code, id) {
+      if (filter(id)) {
+        return {
+          code: `export default ${JSON.stringify(code)}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+__name(rawPlugin, "rawPlugin");
+function cjsPlugin(_opts) {
+  return {
+    name: "unbuild-cjs",
+    renderChunk(code, _chunk, opts) {
+      if (opts.format === "es") {
+        return CJSToESM(code);
+      }
+      return null;
+    }
+  };
+}
+__name(cjsPlugin, "cjsPlugin");
+function fixCJSExportTypePlugin() {
+  return {
+    name: "unbuild-fix-cjs-export-type",
+    renderChunk(code, info, opts) {
+      if (info.type !== "chunk" || !info.fileName.endsWith(".d.cts") || !info.isEntry || info.exports?.length !== 1 || info.exports[0] !== "default") {
+        return;
+      }
+      return code.replace(
+        /(?<=(?<=[;}]|^)\s*export\s*){\s*([\w$]+)\s*as\s+default\s*}/,
+        `= $1`
+      );
+    }
+  };
+}
+__name(fixCJSExportTypePlugin, "fixCJSExportTypePlugin");
+var CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/;
+var CJSShim = `
+
+// -- Unbuild CommonJS Shims --
+import __cjs_url__ from 'url';
+import __cjs_path__ from 'path';
+import __cjs_mod__ from 'module';
+const __filename = __cjs_url__.fileURLToPath(import.meta.url);
+const __dirname = __cjs_path__.dirname(__filename);
+const require = __cjs_mod__.createRequire(import.meta.url);
+`;
+function CJSToESM(code) {
+  if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
+    return null;
+  }
+  const lastESMImport = findStaticImports(code).pop();
+  const indexToAppend = lastESMImport ? lastESMImport.end : 0;
+  const s = new MagicString(code);
+  s.appendRight(indexToAppend, CJSShim);
+  return {
+    code: s.toString(),
+    map: s.generateMap()
+  };
+}
+__name(CJSToESM, "CJSToESM");
+var DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".mjs",
+  ".cjs",
+  ".js",
+  ".jsx",
+  ".json"
+];
+function resolveAliases(ctx) {
+  const aliases = {
+    [ctx.pkg.name]: ctx.options.rootDir,
+    ...ctx.options.alias
+  };
+  if (ctx.options.rollup.alias) {
+    if (Array.isArray(ctx.options.rollup.alias.entries)) {
+      Object.assign(
+        aliases,
+        Object.fromEntries(
+          ctx.options.rollup.alias.entries.map((entry) => {
+            return [entry.find, entry.replacement];
+          })
+        )
+      );
+    } else {
+      Object.assign(
+        aliases,
+        ctx.options.rollup.alias.entries || ctx.options.rollup.alias
+      );
+    }
+  }
+  return aliases;
+}
+__name(resolveAliases, "resolveAliases");
+function getChunkFilename(ctx, chunk, ext) {
+  if (chunk.isDynamicEntry) {
+    return `chunks/[name].${ext}`;
+  }
+  return `shared/${ctx.options.name}.[hash].${ext}`;
+}
+__name(getChunkFilename, "getChunkFilename");
+function getRollupOptions(ctx) {
+  const _aliases = resolveAliases(ctx);
+  return {
+    input: Object.fromEntries(
+      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [
+        entry.name,
+        resolve(ctx.options.rootDir, entry.input)
+      ])
+    ),
+    output: [
+      ctx.options.rollup.emitCJS && {
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].cjs",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "cjs"), "chunkFileNames"),
+        format: "cjs",
+        exports: "auto",
+        interop: "compat",
+        generatedCode: { constBindings: true },
+        externalLiveBindings: false,
+        freeze: false,
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.output
+      },
+      {
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].mjs",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "mjs"), "chunkFileNames"),
+        format: "esm",
+        exports: "auto",
+        generatedCode: { constBindings: true },
+        externalLiveBindings: false,
+        freeze: false,
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.output
+      }
+    ].filter(Boolean),
+    external(originalId) {
+      const resolvedId = resolveAlias(originalId, _aliases);
+      const pkgName = parseNodeModulePath(resolvedId)?.name || parseNodeModulePath(originalId)?.name || getpkg(originalId);
+      if (arrayIncludes(ctx.options.externals, pkgName) || arrayIncludes(ctx.options.externals, originalId) || arrayIncludes(ctx.options.externals, resolvedId)) {
+        return true;
+      }
+      for (const id of [originalId, resolvedId]) {
+        if (id[0] === "." || isAbsolute(id) || /src[/\\]/.test(id) || id.startsWith(ctx.pkg.name)) {
+          return false;
+        }
+      }
+      if (ctx.options.rollup.inlineDependencies === true || Array.isArray(ctx.options.rollup.inlineDependencies) && (arrayIncludes(ctx.options.rollup.inlineDependencies, pkgName) || arrayIncludes(ctx.options.rollup.inlineDependencies, originalId) || arrayIncludes(ctx.options.rollup.inlineDependencies, resolvedId))) {
+        return false;
+      }
+      warn(ctx, `Implicitly bundling "${originalId}"`);
+      return false;
+    },
+    onwarn(warning, rollupWarn) {
+      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+        rollupWarn(warning);
+      }
+    },
+    plugins: [
+      ctx.options.rollup.replace && replace({
+        ...ctx.options.rollup.replace,
+        values: {
+          ...ctx.options.replace,
+          ...ctx.options.rollup.replace.values
+        }
+      }),
+      ctx.options.rollup.alias && alias({
+        ...ctx.options.rollup.alias,
+        entries: _aliases
+      }),
+      ctx.options.rollup.resolve && nodeResolve({
+        extensions: DEFAULT_EXTENSIONS,
+        exportConditions: ["production"],
+        ...ctx.options.rollup.resolve
+      }),
+      ctx.options.rollup.json && JSONPlugin({
+        ...ctx.options.rollup.json
+      }),
+      shebangPlugin(),
+      ctx.options.rollup.esbuild && esbuild({
+        sourcemap: ctx.options.sourcemap,
+        ...ctx.options.rollup.esbuild
+      }),
+      ctx.options.rollup.commonjs && commonjs({
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.commonjs
+      }),
+      ctx.options.rollup.preserveDynamicImports && {
+        renderDynamicImport() {
+          return { left: "import(", right: ")" };
+        }
+      },
+      ctx.options.rollup.cjsBridge && cjsPlugin(),
+      rawPlugin()
+    ].filter(Boolean)
+  };
+}
+__name(getRollupOptions, "getRollupOptions");
+async function rollupStub(ctx) {
+  const babelPlugins = ctx.options.stubOptions.jiti.transformOptions?.babel?.plugins;
+  const importedBabelPlugins = [];
+  const serializedJitiOptions = JSON.stringify(
+    {
+      ...ctx.options.stubOptions.jiti,
+      alias: {
+        ...resolveAliases(ctx),
+        ...ctx.options.stubOptions.jiti.alias
+      },
+      transformOptions: {
+        ...ctx.options.stubOptions.jiti.transformOptions,
+        babel: {
+          ...ctx.options.stubOptions.jiti.transformOptions?.babel,
+          plugins: "__$BABEL_PLUGINS"
+        }
+      }
+    },
+    null,
+    2
+  ).replace(
+    '"__$BABEL_PLUGINS"',
+    Array.isArray(babelPlugins) ? "[" + babelPlugins.map((plugin, i) => {
+      if (Array.isArray(plugin)) {
+        const [name, ...args] = plugin;
+        importedBabelPlugins.push(name);
+        return `[` + [
+          `plugin${i}`,
+          ...args.map((val) => JSON.stringify(val))
+        ].join(", ") + "]";
+      } else {
+        importedBabelPlugins.push(plugin);
+        return `plugin${i}`;
+      }
+    }).join(",") + "]" : "[]"
+  );
+  for (const entry of ctx.options.entries.filter(
+    (entry2) => entry2.builder === "rollup"
+  )) {
+    const output = resolve(
+      ctx.options.rootDir,
+      ctx.options.outDir,
+      entry.name
+    );
+    const isESM = ctx.pkg.type === "module";
+    const resolvedEntry = fileURLToPath(ctx.jiti.esmResolve(entry.input));
+    const resolvedEntryWithoutExt = resolvedEntry.slice(
+      0,
+      Math.max(0, resolvedEntry.length - extname(resolvedEntry).length)
+    );
+    const resolvedEntryForTypeImport = isESM ? `${resolvedEntry.replace(/(\.m?)(ts)$/, "$1js")}` : resolvedEntryWithoutExt;
+    const code = await promises.readFile(resolvedEntry, "utf8");
+    const shebang = getShebang(code);
+    await mkdir(dirname(output), { recursive: true });
+    if (ctx.options.rollup.emitCJS) {
+      const jitiCJSPath = relative2(
+        dirname(output),
+        await resolvePath("jiti", {
+          url: import.meta.url,
+          conditions: ["node", "require"]
+        })
+      );
+      await writeFile2(
+        output + ".cjs",
+        shebang + [
+          `const { createJiti } = require(${JSON.stringify(jitiCJSPath)})`,
+          ...importedBabelPlugins.map(
+            (plugin, i) => `const plugin${i} = require(${JSON.stringify(plugin)})`
+          ),
+          "",
+          `const jiti = createJiti(__filename, ${serializedJitiOptions})`,
+          "",
+          `/** @type {import(${JSON.stringify(
+            resolvedEntryForTypeImport
+          )})} */`,
+          `module.exports = jiti(${JSON.stringify(resolvedEntry)})`
+        ].join("\n")
+      );
+    }
+    const namedExports = await resolveModuleExportNames(
+      resolvedEntry,
+      {
+        extensions: DEFAULT_EXTENSIONS
+      }
+    ).catch((error) => {
+      warn(ctx, `Cannot analyze ${resolvedEntry} for exports:` + error);
+      return [];
+    });
+    const hasDefaultExport = namedExports.includes("default") || namedExports.length === 0;
+    const jitiESMPath = relative2(
+      dirname(output),
+      await resolvePath("jiti", {
+        url: import.meta.url,
+        conditions: ["node", "import"]
+      })
+    );
+    await writeFile2(
+      output + ".mjs",
+      shebang + [
+        `import { createJiti } from ${JSON.stringify(jitiESMPath)};`,
+        ...importedBabelPlugins.map(
+          (plugin, i) => `import plugin${i} from ${JSON.stringify(plugin)}`
+        ),
+        "",
+        `const jiti = createJiti(import.meta.url, ${serializedJitiOptions})`,
+        "",
+        `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
+        `const _module = await jiti.import(${JSON.stringify(
+          resolvedEntry
+        )});`,
+        hasDefaultExport ? "\nexport default _module?.default ?? _module;" : "",
+        ...namedExports.filter((name) => name !== "default").map((name) => `export const ${name} = _module.${name};`)
+      ].join("\n")
+    );
+    if (ctx.options.declaration) {
+      const dtsContent = [
+        `export * from ${JSON.stringify(resolvedEntryForTypeImport)};`,
+        hasDefaultExport ? `export { default } from ${JSON.stringify(resolvedEntryForTypeImport)};` : ""
+      ].join("\n");
+      await writeFile2(output + ".d.cts", dtsContent);
+      await writeFile2(output + ".d.mts", dtsContent);
+      if (ctx.options.declaration === "compatible" || ctx.options.declaration === true) {
+        await writeFile2(output + ".d.ts", dtsContent);
+      }
+    }
+    if (shebang) {
+      await makeExecutable(output + ".cjs");
+      await makeExecutable(output + ".mjs");
+    }
+  }
+}
+__name(rollupStub, "rollupStub");
+function rollupWatch(rollupOptions) {
+  const watcher = watch(rollupOptions);
+  let inputs;
+  if (Array.isArray(rollupOptions.input)) {
+    inputs = rollupOptions.input;
+  } else if (typeof rollupOptions.input === "string") {
+    inputs = [rollupOptions.input];
+  } else {
+    inputs = Object.keys(rollupOptions.input || {});
+  }
+  consola$1.info(
+    `[unbuild] [rollup] Starting watchers for entries: ${inputs.map((input) => "./" + relative2(process.cwd(), input)).join(", ")}`
+  );
+  consola$1.warn(
+    "[unbuild] [rollup] Watch mode is experimental and may be unstable"
+  );
+  watcher.on("change", (id, { event }) => {
+    consola$1.info(`${colors.cyan(relative2(".", id))} was ${event}d`);
+  });
+  watcher.on("restart", () => {
+    consola$1.info(colors.gray("[unbuild] [rollup] Rebuilding bundle"));
+  });
+  watcher.on("event", (event) => {
+    if (event.code === "END") {
+      consola$1.success(colors.green("[unbuild] [rollup] Rebuild finished\n"));
+    }
+  });
+}
+__name(rollupWatch, "rollupWatch");
+async function rollupBuild(ctx) {
+  if (ctx.options.stub) {
+    await rollupStub(ctx);
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const rollupOptions = getRollupOptions(ctx);
+  await ctx.hooks.callHook("rollup:options", ctx, rollupOptions);
+  if (Object.keys(rollupOptions.input).length === 0) {
+    await ctx.hooks.callHook("rollup:done", ctx);
+    return;
+  }
+  const buildResult = await rollup(rollupOptions);
+  await ctx.hooks.callHook("rollup:build", ctx, buildResult);
+  const allOutputOptions = rollupOptions.output;
+  for (const outputOptions of allOutputOptions) {
+    const { output } = await buildResult.write(outputOptions);
+    const chunkFileNames = /* @__PURE__ */ new Set();
+    const outputChunks = output.filter(
+      (e) => e.type === "chunk"
+    );
+    for (const entry of outputChunks) {
+      chunkFileNames.add(entry.fileName);
+      for (const id of entry.imports) {
+        ctx.usedImports.add(id);
+      }
+      if (entry.isEntry) {
+        ctx.buildEntries.push({
+          chunks: entry.imports.filter(
+            (i) => outputChunks.find((c) => c.fileName === i)
+          ),
+          modules: Object.entries(entry.modules).map(([id, mod]) => ({
+            id,
+            bytes: mod.renderedLength
+          })),
+          path: entry.fileName,
+          bytes: Buffer.byteLength(entry.code, "utf8"),
+          exports: entry.exports
+        });
+      }
+    }
+    for (const chunkFileName of chunkFileNames) {
+      ctx.usedImports.delete(chunkFileName);
+    }
+  }
+  if (ctx.options.watch) {
+    rollupWatch(rollupOptions);
+    if (ctx.options.declaration && ctx.options.watch) {
+      consola$1.warn("`rollup` DTS builder does not support watch mode yet.");
+    }
+    return;
+  }
+  if (ctx.options.declaration) {
+    rollupOptions.plugins = [
+      ...rollupOptions.plugins,
+      dts(ctx.options.rollup.dts),
+      removeShebangPlugin(),
+      ctx.options.rollup.emitCJS && fixCJSExportTypePlugin()
+    ].filter(Boolean);
+    await ctx.hooks.callHook("rollup:dts:options", ctx, rollupOptions);
+    const typesBuild2 = await rollup(rollupOptions);
+    await ctx.hooks.callHook("rollup:dts:build", ctx, typesBuild2);
+    if (ctx.options.rollup.emitCJS) {
+      await typesBuild2.write({
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.cts",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.cts"), "chunkFileNames")
+      });
+    }
+    await typesBuild2.write({
+      dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+      entryFileNames: "[name].d.mts",
+      chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.mts"), "chunkFileNames")
+    });
+    if (ctx.options.declaration === true || ctx.options.declaration === "compatible") {
+      await typesBuild2.write({
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].d.ts",
+        chunkFileNames: /* @__PURE__ */ __name((chunk) => getChunkFilename(ctx, chunk, "d.ts"), "chunkFileNames")
+      });
+    }
+  }
+  await ctx.hooks.callHook("rollup:done", ctx);
+}
+__name(rollupBuild, "rollupBuild");
+async function typesBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (entry) => entry.builder === "untyped"
+  );
+  await ctx.hooks.callHook("untyped:entries", ctx, entries);
+  for (const entry of entries) {
+    const options = {
+      jiti: {
+        interopDefault: true,
+        transformOptions: {
+          babel: {
+            plugins: [untypedPlugin]
+          }
+        }
+      }
+    };
+    await ctx.hooks.callHook("untyped:entry:options", ctx, entry, options);
+    const untypedJiti = createJiti(ctx.options.rootDir, options.jiti);
+    const distDir = entry.outDir;
+    let rawSchema = await untypedJiti.import(resolve(ctx.options.rootDir, entry.input), {
+      try: true
+    }) || {};
+    const rawSchemaKeys = Object.keys(rawSchema);
+    if (rawSchemaKeys.length === 1 && rawSchemaKeys[0] === "default") {
+      rawSchema = rawSchema.default;
+    }
+    const defaults2 = entry.defaults || {};
+    const schema = await resolveSchema(rawSchema, defaults2);
+    await ctx.hooks.callHook("untyped:entry:schema", ctx, entry, schema);
+    const outputs = {
+      markdown: {
+        fileName: resolve(distDir, `${entry.name}.md`),
+        contents: generateMarkdown(schema)
+      },
+      schema: {
+        fileName: `${entry.name}.schema.json`,
+        contents: JSON.stringify(schema, null, 2)
+      },
+      defaults: {
+        fileName: `${entry.name}.defaults.json`,
+        contents: JSON.stringify(defaults2, null, 2)
+      },
+      declaration: entry.declaration ? {
+        fileName: `${entry.name}.d.ts`,
+        contents: generateTypes(schema, {
+          interfaceName: pascalCase(entry.name + "-schema")
+        })
+      } : void 0
+    };
+    await ctx.hooks.callHook("untyped:entry:outputs", ctx, entry, outputs);
+    for (const output of Object.values(outputs)) {
+      if (!output) continue;
+      await writeFile2(
+        resolve(distDir, output.fileName),
+        output.contents,
+        "utf8"
+      );
+    }
+  }
+  await ctx.hooks.callHook("untyped:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    consola$1.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+__name(typesBuild, "typesBuild");
+async function mkdistBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "mkdist"
+  );
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir;
+    if (ctx.options.stub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const mkdistOptions = {
+        rootDir: ctx.options.rootDir,
+        srcDir: entry.input,
+        distDir,
+        cleanDist: false,
+        ...entry
+      };
+      await ctx.hooks.callHook(
+        "mkdist:entry:options",
+        ctx,
+        entry,
+        mkdistOptions
+      );
+      const output = await mkdist(mkdistOptions);
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: output.writtenFiles.map((p) => relative2(ctx.options.outDir, p))
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors) {
+        for (const error of output.errors) {
+          warn(
+            ctx,
+            `mkdist build failed for \`${relative2(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
+          );
+        }
+      }
+    }
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    consola$1.warn("`mkdist` builder does not support watch mode yet.");
+  }
+}
+__name(mkdistBuild, "mkdistBuild");
+var copy = promises.cp || promises.copyFile;
+async function copyBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (e) => e.builder === "copy"
+  );
+  await ctx.hooks.callHook("copy:entries", ctx, entries);
+  for (const entry of entries) {
+    const distDir = entry.outDir;
+    if (ctx.options.stub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+    } else {
+      const patterns = Array.isArray(entry.pattern) ? entry.pattern : [entry.pattern || "**"];
+      const paths = await glob3(patterns, {
+        cwd: resolve(ctx.options.rootDir, entry.input),
+        absolute: false
+      });
+      const outputList = await Promise.allSettled(
+        paths.map(async (path2) => {
+          const src = resolve(ctx.options.rootDir, entry.input, path2);
+          const dist = resolve(ctx.options.rootDir, distDir, path2);
+          await copy(src, dist);
+          return dist;
+        })
+      );
+      for (const output of outputList) {
+        if (output.status === "rejected") {
+          warn(ctx, output.reason);
+        }
+      }
+      ctx.buildEntries.push({
+        path: distDir,
+        chunks: outputList.filter(({ status }) => status === "fulfilled").map(
+          (p) => relative2(
+            ctx.options.outDir,
+            p.value
+          )
+        )
+      });
+    }
+  }
+  await ctx.hooks.callHook("copy:done", ctx);
+  if (entries.length > 0 && ctx.options.watch) {
+    consola$1.warn("`untyped` builder does not support watch mode yet.");
+  }
+}
+__name(copyBuild, "copyBuild");
+async function build(rootDir, stub, inputConfig = {}) {
+  rootDir = resolve(process.cwd(), rootDir || ".");
+  const jiti = createJiti(rootDir);
+  const _buildConfig = await jiti.import(inputConfig?.config || "./build.config", {
+    try: !inputConfig.config,
+    default: true
+  }) || {};
+  const buildConfigs = (Array.isArray(_buildConfig) ? _buildConfig : [_buildConfig]).filter(Boolean);
+  const pkg = await jiti.import("./package.json", {
+    try: true,
+    default: true
+  }) || {};
+  const cleanedDirs = [];
+  const _watchMode = inputConfig.watch === true;
+  const _stubMode = !_watchMode && (stub || inputConfig.stub === true);
+  for (const buildConfig of buildConfigs) {
+    await _build(
+      rootDir,
+      inputConfig,
+      buildConfig,
+      pkg,
+      cleanedDirs,
+      _stubMode,
+      _watchMode
+    );
+  }
+}
+__name(build, "build");
+async function _build(rootDir, inputConfig = {}, buildConfig, pkg, cleanedDirs, _stubMode, _watchMode) {
+  const preset = await resolvePreset(
+    buildConfig.preset || pkg.unbuild?.preset || pkg.build?.preset || inputConfig.preset || "auto",
+    rootDir
+  );
+  const options = defu3(
+    buildConfig,
+    pkg.unbuild || pkg.build,
+    inputConfig,
+    preset,
+    {
+      name: (pkg?.name || "").split("/").pop() || "default",
+      rootDir,
+      entries: [],
+      clean: true,
+      declaration: void 0,
+      outDir: "dist",
+      stub: _stubMode,
+      stubOptions: {
+        /**
+         * See https://github.com/unjs/jiti#%EF%B8%8F-options
+         */
+        jiti: {
+          interopDefault: true,
+          alias: {}
+        }
+      },
+      watch: _watchMode,
+      watchOptions: _watchMode ? {
+        exclude: "node_modules/**",
+        include: "src/**"
+      } : void 0,
+      externals: [
+        ...Module.builtinModules,
+        ...Module.builtinModules.map((m) => "node:" + m)
+      ],
+      dependencies: [],
+      devDependencies: [],
+      peerDependencies: [],
+      alias: {},
+      replace: {},
+      failOnWarn: true,
+      sourcemap: false,
+      rollup: {
+        emitCJS: false,
+        watch: false,
+        cjsBridge: false,
+        inlineDependencies: false,
+        preserveDynamicImports: true,
+        output: {
+          // https://v8.dev/features/import-attributes
+          importAttributesKey: "with"
+        },
+        // Plugins
+        replace: {
+          preventAssignment: true
+        },
+        alias: {},
+        resolve: {
+          preferBuiltins: true
+        },
+        json: {
+          preferConst: true
+        },
+        commonjs: {
+          ignoreTryCatch: true
+        },
+        esbuild: { target: "esnext" },
+        dts: {
+          // https://github.com/Swatinem/rollup-plugin-dts/issues/143
+          compilerOptions: { preserveSymlinks: false },
+          respectExternal: true
+        }
+      },
+      parallel: false
+    }
+  );
+  options.outDir = resolve(options.rootDir, options.outDir);
+  const jiti = createJiti(options.rootDir, { interopDefault: true });
+  const ctx = {
+    options,
+    jiti,
+    warnings: /* @__PURE__ */ new Set(),
+    pkg,
+    buildEntries: [],
+    usedImports: /* @__PURE__ */ new Set(),
+    hooks: createHooks()
+  };
+  if (preset.hooks) {
+    ctx.hooks.addHooks(preset.hooks);
+  }
+  if (inputConfig.hooks) {
+    ctx.hooks.addHooks(inputConfig.hooks);
+  }
+  if (buildConfig.hooks) {
+    ctx.hooks.addHooks(buildConfig.hooks);
+  }
+  await ctx.hooks.callHook("build:prepare", ctx);
+  options.entries = options.entries.map(
+    (entry) => typeof entry === "string" ? { input: entry } : entry
+  );
+  for (const entry of options.entries) {
+    if (typeof entry.name !== "string") {
+      let relativeInput = isAbsolute(entry.input) ? relative2(rootDir, entry.input) : normalize(entry.input);
+      if (relativeInput.startsWith("./")) {
+        relativeInput = relativeInput.slice(2);
+      }
+      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
+    }
+    if (!entry.input) {
+      throw new Error("Missing entry input: " + dumpObject(entry));
+    }
+    if (!entry.builder) {
+      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
+    }
+    if (options.declaration !== void 0 && entry.declaration === void 0) {
+      entry.declaration = options.declaration;
+    }
+    entry.input = resolve(options.rootDir, entry.input);
+    entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
+  }
+  options.dependencies = Object.keys(pkg.dependencies || {});
+  options.peerDependencies = Object.keys(pkg.peerDependencies || {});
+  options.devDependencies = Object.keys(pkg.devDependencies || {});
+  options.externals.push(...inferPkgExternals(pkg));
+  options.externals = [...new Set(options.externals)];
+  await ctx.hooks.callHook("build:before", ctx);
+  consola.info(
+    colors.cyan(`${options.stub ? "Stubbing" : "Building"} ${options.name}`)
+  );
+  if (process.env.DEBUG) {
+    consola.info(`${colors.bold("Root dir:")} ${options.rootDir}
+  ${colors.bold("Entries:")}
+  ${options.entries.map((entry) => "  " + dumpObject(entry)).join("\n  ")}
+`);
+  }
+  if (options.clean) {
+    for (const dir of new Set(
+      options.entries.map((e) => e.outDir).filter(Boolean).sort()
+    )) {
+      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
+        continue;
+      }
+      cleanedDirs.push(dir);
+      consola.info(
+        `Cleaning dist directory: \`./${relative2(process.cwd(), dir)}\``
+      );
+      await rmdir(dir);
+      await promises.mkdir(dir, { recursive: true });
+    }
+  }
+  const buildTasks = [
+    typesBuild,
+    // untyped
+    mkdistBuild,
+    // mkdist
+    rollupBuild,
+    // rollup
+    copyBuild
+    // copy
+  ];
+  if (options.parallel) {
+    await Promise.all(buildTasks.map((task) => task(ctx)));
+  } else {
+    for (const task of buildTasks) {
+      await task(ctx);
+    }
+  }
+  if (options.stub || options.watch) {
+    await ctx.hooks.callHook("build:done", ctx);
+    return;
+  }
+  consola.success(colors.green("Build succeeded for " + options.name));
+  const outFiles = await glob3(["**"], { cwd: options.outDir });
+  for (const file of outFiles) {
+    let entry = ctx.buildEntries.find((e) => e.path === file);
+    if (!entry) {
+      entry = {
+        path: file,
+        chunk: true
+      };
+      ctx.buildEntries.push(entry);
+    }
+    if (!entry.bytes) {
+      const stat = await promises.stat(resolve(options.outDir, file));
+      entry.bytes = stat.size;
+    }
+  }
+  const rPath = /* @__PURE__ */ __name((p) => relative2(process.cwd(), resolve(options.outDir, p)), "rPath");
+  for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
+    let totalBytes = entry.bytes || 0;
+    for (const chunk of entry.chunks || []) {
+      totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
+    }
+    let line = `  ${colors.bold(rPath(entry.path))} (` + [
+      totalBytes && `total size: ${colors.cyan(prettyBytes(totalBytes))}`,
+      entry.bytes && `chunk size: ${colors.cyan(prettyBytes(entry.bytes))}`,
+      entry.exports?.length && `exports: ${colors.gray(entry.exports.join(", "))}`
+    ].filter(Boolean).join(", ") + ")";
+    if (entry.chunks?.length) {
+      line += "\n" + entry.chunks.map((p) => {
+        const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+        return colors.gray(
+          "  \u2514\u2500 " + rPath(p) + colors.bold(
+            chunk.bytes ? ` (${prettyBytes(chunk?.bytes)})` : ""
+          )
+        );
+      }).join("\n");
+    }
+    if (entry.modules?.length) {
+      line += "\n" + entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
+        return colors.gray(
+          "  \u{1F4E6} " + rPath(m.id) + colors.bold(m.bytes ? ` (${prettyBytes(m.bytes)})` : "")
+        );
+      }).join("\n");
+    }
+    consola.log(entry.chunk ? colors.gray(line) : line);
+  }
+  console.log(
+    "\u03A3 Total dist size (byte size):",
+    colors.cyan(
+      prettyBytes(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0))
+    )
+  );
+  validateDependencies(ctx);
+  validatePackage(pkg, rootDir, ctx);
+  await ctx.hooks.callHook("build:done", ctx);
+  consola.log("");
+  if (ctx.warnings.size > 0) {
+    consola.warn(
+      "Build is done with some warnings:\n\n" + [...ctx.warnings].map((msg) => "- " + msg).join("\n")
+    );
+    if (ctx.options.failOnWarn) {
+      consola.error(
+        "Exiting with code (1). You can change this behavior by setting `failOnWarn: false` ."
+      );
+      process.exit(1);
+    }
+  }
+}
+__name(_build, "_build");
+
+// ../../node_modules/.pnpm/unbuild@3.3.1_sass@1.83.4_typescript@5.7.3/node_modules/unbuild/dist/index.mjs
+import "node:module";
+import "node:fs";
+import "pathe";
+import "consola/utils";
+import "consola";
+import "defu";
+import "hookable";
+import "pretty-bytes";
+import "tinyglobby";
+import "node:fs/promises";
+import "jiti";
+import "rollup";
+import "rollup-plugin-dts";
+import "@rollup/plugin-commonjs";
+import "@rollup/plugin-node-resolve";
+import "@rollup/plugin-alias";
+import "@rollup/plugin-replace";
+import "pathe/utils";
+import "mlly";
+import "esbuild";
+import "@rollup/pluginutils";
+import "@rollup/plugin-json";
+import "magic-string";
+import "untyped";
+import "untyped/babel-plugin";
+import "scule";
+import "mkdist";
+
+// src/build.ts
+async function resolveOptions(options, config) {
+  writeDebug("  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = getStopwatch("Build options resolution");
+  if (options.configPath) {
+    const configFile = await loadConfig(options.configPath);
+    if (configFile) {
+      options = defu4(options, configFile);
+    }
+  }
+  const outputPath = options.outputPath || joinPaths("dist", options.projectRoot);
+  const projectGraph = readCachedProjectGraph3();
+  const projectJsonPath = joinPaths(config.workspaceRoot, options.projectRoot, "project.json");
+  if (!existsSync4(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonContent = await readFile4(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonContent);
+  const projectName = projectJson.name;
+  const packageJsonPath = joinPaths(config.workspaceRoot, options.projectRoot, "package.json");
+  if (!existsSync4(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJsonContent = await readFile4(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = joinPaths(config.workspaceRoot, options.projectRoot, "tsconfig.json");
+  }
+  if (!existsSync4(tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = joinPaths(options.projectRoot, "src");
+  }
+  if (!existsSync4(sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const result = calculateProjectBuildableDependencies2(void 0, projectGraph, config.workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = getHelperDependency(HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot: options.projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(options.projectRoot, "")}`,
+        outDir: joinPaths(relative3(joinPaths(config.workspaceRoot, options.projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(options.projectRoot, "")}`,
+        outDir: joinPaths(relative3(joinPaths(config.workspaceRoot, options.projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: options.sourcemap ?? !!options.debug,
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: options.external ?? [],
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: options.sourcemap ?? true
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: options.minify !== false,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup2 = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await loadConfig(options.rollup);
+      if (rollupFile) {
+        rollup2 = rollupFile;
+      }
+    } else {
+      rollup2 = options.rollup;
+    }
+    resolvedOptions.rollup = defu4(resolvedOptions.rollup ?? {}, rollup2);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
+      opts.plugins = options.plugins ?? await getDefaultBuildPlugins(options, resolvedOptions);
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+__name(resolveOptions, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && existsSync4(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 (!existsSync4(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJsonContent = await readFile4(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    if (!packageJsonContent) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    let packageJson = JSON.parse(packageJsonContent);
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    await writeJsonFile(joinPaths(options.outDir, "package.json"), await addPackageJsonExports(options.sourceRoot, packageJson));
+    stopwatch();
+  }
+  return options;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function executeUnbuild(options) {
+  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
+  try {
+    await build(options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+__name(executeUnbuild, "executeUnbuild");
+async function copyBuildAssets(options) {
+  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;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outDir) {
+    writeDebug(` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outDir}`, options.config);
+    const stopwatch = getStopwatch(`${options.name} output clean`);
+    await cleanDirectories(options.name, options.outDir, options.config);
+    stopwatch();
+  }
+  return options;
+}
+__name(cleanOutputPath, "cleanOutputPath");
+async function build2(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const workspaceRoot = findWorkspaceRoot2(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await loadStormConfig(workspaceRoot.dir);
+  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`, config);
+  const stopwatch = getStopwatch("Unbuild pipeline");
+  try {
+    options.projectRoot = projectRoot;
+    const resolvedOptions = await resolveOptions(options, config);
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, config);
+  } catch (error) {
+    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.", config);
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+__name(build2, "build");
+
+export {
+  build2 as build
+};