bunup 0.8.42 → 0.8.44

package/dist/cli/index.js

@@ -1,952 +1,40 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/logger.ts
-import pc from "picocolors";
-function setSilent(value) {
-  silent = value ?? false;
-}
-
-class Logger {
-  static instance;
-  loggedOnceMessages = new Set;
-  constructor() {}
-  static getInstance() {
-    if (!Logger.instance) {
-      Logger.instance = new Logger;
-    }
-    return Logger.instance;
-  }
-  dispose() {
-    this.loggedOnceMessages.clear();
-  }
-  shouldLog(options) {
-    if (!options?.once) {
-      return true;
-    }
-    if (this.loggedOnceMessages.has(options.once)) {
-      return false;
-    }
-    this.loggedOnceMessages.add(options.once);
-    return true;
-  }
-  getIcon(type, tick) {
-    if (tick) {
-      return pc.green("\u2713");
-    }
-    const iconMap = {
-      info: pc.blue("i"),
-      warn: pc.yellow("!"),
-      error: pc.red("\u2715")
-    };
-    return iconMap[type];
-  }
-  formatIdentifier(identifier) {
-    return identifier ? `   ${pc.bgBlue(pc.black(` ${identifier} `))}` : "";
-  }
-  formatMessage(options) {
-    const {
-      message,
-      identifier,
-      muted = false,
-      tick = false,
-      type = "info"
-    } = options;
-    const icon = this.getIcon(type, tick);
-    const styledMessage = muted ? pc.dim(message) : type === "error" ? pc.red(message) : type === "warn" ? pc.yellow(message) : message;
-    const identifierPart = this.formatIdentifier(identifier);
-    return `${icon} ${styledMessage}${identifierPart}`;
-  }
-  output(message, options = {}, logFn = console.log) {
-    if (silent || !this.shouldLog(options)) {
-      return;
-    }
-    if (options.verticalSpace) {
-      logFn("");
-    }
-    logFn(message);
-    if (options.verticalSpace) {
-      logFn("");
-    }
-  }
-  info(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      ...options,
-      message,
-      type: "info"
-    });
-    this.output(formattedMessage, options);
-  }
-  warn(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      ...options,
-      message,
-      type: "warn"
-    });
-    this.output(formattedMessage, options);
-  }
-  error(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      ...options,
-      message,
-      type: "error"
-    });
-    this.output(formattedMessage, options);
-  }
-  success(message, options = {}) {
-    const formattedMessage = this.formatMessage({
-      ...options,
-      message,
-      tick: true
-    });
-    this.output(formattedMessage, options);
-  }
-  space() {
-    if (!silent) {
-      console.log("");
-    }
-  }
-}
-function logTable(columns, data, footer) {
-  if (silent)
-    return;
-  const widths = {};
-  for (const col of columns) {
-    const headerLength = col.header.length;
-    const dataLengths = data.map((row) => row[col.header]?.length || 0);
-    const footerLength = footer ? footer[col.header]?.length || 0 : 0;
-    widths[col.header] = Math.max(headerLength, ...dataLengths, footerLength);
-  }
-  const pad = (str, width, align) => {
-    return align === "left" ? str.padEnd(width) : str.padStart(width);
-  };
-  const headerRow = columns.map((col) => pad(col.header, widths[col.header], col.align)).join(pc.gray(" | "));
-  console.log(pc.gray(headerRow));
-  const separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
-  console.log(pc.gray(separator));
-  for (const row of data) {
-    const rowStr = columns.map((col) => {
-      const value = row[col.header] || "";
-      const padded = pad(value, widths[col.header], col.align);
-      return col.color ? col.color(padded) : padded;
-    }).join(pc.gray(" | "));
-    console.log(rowStr);
-  }
-  console.log(pc.gray(separator));
-  if (footer) {
-    const footerRow = columns.map((col) => {
-      const value = footer[col.header] || "";
-      const padded = pad(value, widths[col.header], col.align);
-      return padded;
-    }).join(pc.gray(" | "));
-    console.log(footerRow);
-  }
-}
-var silent = false, logger;
-var init_logger = __esm(() => {
-  logger = Logger.getInstance();
-});
-
-// src/errors.ts
-import pc2 from "picocolors";
-var BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}, KNOWN_ERRORS, handleError = (error, context) => {
-  const errorMessage = parseErrorMessage(error);
-  const contextPrefix = context ? `[${context}] ` : "";
-  let errorType = "UNKNOWN ERROR";
-  if (error instanceof BunupBuildError) {
-    errorType = "BUILD ERROR";
-  } else if (error instanceof BunupDTSBuildError) {
-    errorType = "DTS ERROR";
-  } else if (error instanceof BunupCLIError) {
-    errorType = "CLI ERROR";
-  } else if (error instanceof BunupWatchError) {
-    errorType = "WATCH ERROR";
-  } else if (error instanceof BunupPluginError) {
-    errorType = "PLUGIN ERROR";
-  } else if (error instanceof BunupError) {
-    errorType = "BUNUP ERROR";
-  }
-  const knownError = KNOWN_ERRORS.find((error2) => error2.pattern.test(errorMessage) && (error2.errorType === errorType || !error2.errorType));
-  if (!knownError && errorType) {
-    console.error(`${pc2.red(errorType)} ${contextPrefix}${errorMessage}`);
-  }
-  if (knownError) {
-    console.log(`
-`);
-    knownError.logSolution(errorMessage);
-    console.log(`
-`);
-  } else {
-    console.error(pc2.dim(pc2.white("If you think this is a bug, please open an issue at: ") + pc2.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
-  }
-}, handleErrorAndExit = (error, context) => {
-  handleError(error, context);
-  process.exit(1);
-};
-var init_errors = __esm(() => {
-  init_logger();
-  BunupError = class BunupError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "BunupError";
-    }
-  };
-  BunupBuildError = class BunupBuildError extends BunupError {
-    constructor(message) {
-      super(message);
-      this.name = "BunupBuildError";
-    }
-  };
-  BunupDTSBuildError = class BunupDTSBuildError extends BunupError {
-    constructor(message) {
-      super(message);
-      this.name = "BunupDTSBuildError";
-    }
-  };
-  BunupCLIError = class BunupCLIError extends BunupError {
-    constructor(message) {
-      super(message);
-      this.name = "BunupCLIError";
-    }
-  };
-  BunupWatchError = class BunupWatchError extends BunupError {
-    constructor(message) {
-      super(message);
-      this.name = "BunupWatchError";
-    }
-  };
-  BunupPluginError = class BunupPluginError extends BunupError {
-    constructor(message) {
-      super(message);
-      this.name = "BunupPluginError";
-    }
-  };
-  KNOWN_ERRORS = [
-    {
-      pattern: /Could not resolve: "bun"/i,
-      errorType: "BUILD ERROR",
-      logSolution: () => {
-        logger.info(pc2.white("You're trying to build a project that uses Bun. ") + pc2.white("Please set the target option to ") + pc2.cyan("`bun`") + pc2.white(`.
-`) + pc2.white("Example: ") + pc2.green("`bunup --target bun`") + pc2.white(" or in config: ") + pc2.green("{ target: 'bun' }"));
-      }
-    }
-  ];
-});
-
-// src/loaders.ts
-import path from "path";
-import { loadConfig } from "coffi";
-async function processLoadedConfigs(config, cwd, filter) {
-  return Array.isArray(config) && "root" in config[0] ? config.filter((c) => filter ? filter.includes(c.name) : true).map((c) => ({
-    rootDir: path.resolve(cwd, c.root),
-    options: addField(c.config, "name", c.name)
-  })) : [
-    {
-      rootDir: cwd,
-      options: config
-    }
-  ];
-}
-function addField(objectOrArray, field, value) {
-  return Array.isArray(objectOrArray) ? objectOrArray.map((o) => ({ ...o, [field]: value })) : { ...objectOrArray, [field]: value };
-}
-async function loadPackageJson(cwd = process.cwd()) {
-  const { config, filepath } = await loadConfig({
-    name: "package",
-    cwd,
-    extensions: [".json"]
-  });
-  return {
-    data: config,
-    path: filepath
-  };
-}
-var init_loaders = () => {};
-
-// src/utils.ts
-import fsSync from "fs";
-import fs from "fs/promises";
-import path2, { normalize } from "path";
-function ensureArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-function getDefaultOutputExtension(format, packageType) {
-  switch (format) {
-    case "esm":
-      return isModulePackage(packageType) ? ".js" : ".mjs";
-    case "cjs":
-      return isModulePackage(packageType) ? ".cjs" : ".js";
-    case "iife":
-      return ".global.js";
-  }
-}
-function getDefaultDtsExtention(format, packageType) {
-  switch (format) {
-    case "esm":
-      return isModulePackage(packageType) ? ".d.ts" : ".d.mts";
-    case "cjs":
-      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
-    case "iife":
-      return ".global.d.ts";
-  }
-}
-function isModulePackage(packageType) {
-  return packageType === "module";
-}
-function formatTime(ms) {
-  return ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;
-}
-function getPackageDeps(packageJson) {
-  if (!packageJson)
-    return [];
-  return Array.from(new Set([
-    ...Object.keys(packageJson.dependencies || {}),
-    ...Object.keys(packageJson.peerDependencies || {})
-  ]));
-}
-function formatFileSize(bytes) {
-  if (bytes === 0)
-    return "0 B";
-  const units = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  if (i === 0)
-    return `${bytes} ${units[i]}`;
-  return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
-}
-function getShortFilePath(filePath, maxLength = 3) {
-  const fileParts = filePath.split("/");
-  const shortPath = fileParts.slice(-maxLength).join("/");
-  return shortPath;
-}
-async function cleanOutDir(rootDir, outDir) {
-  const outDirPath = path2.join(rootDir, outDir);
-  try {
-    await fs.rm(outDirPath, { recursive: true, force: true });
-  } catch (error) {
-    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
-  }
-  await fs.mkdir(outDirPath, { recursive: true });
-}
-function cleanPath(path3) {
-  let cleaned = normalize(path3).replace(/\\/g, "/");
-  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
-  cleaned = cleaned.replace(/^\/+/, "");
-  cleaned = cleaned.replace(/\/+/g, "/");
-  return cleaned;
-}
-function isDirectoryPath(filePath) {
-  return path2.extname(filePath) === "";
-}
-function pathExistsSync(filePath) {
-  try {
-    fsSync.accessSync(filePath);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-function formatListWithAnd(arr) {
-  return new Intl.ListFormat("en", {
-    style: "long",
-    type: "conjunction"
-  }).format(arr);
-}
-async function getFilesFromGlobs(patterns, cwd) {
-  const includePatterns = patterns.filter((p) => !p.startsWith("!"));
-  const excludePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
-  const includedFiles = new Set;
-  for (const pattern of includePatterns) {
-    const glob = new Bun.Glob(pattern);
-    for await (const file of glob.scan(cwd)) {
-      includedFiles.add(file);
-    }
-  }
-  if (excludePatterns.length > 0) {
-    for (const pattern of excludePatterns) {
-      const glob = new Bun.Glob(pattern);
-      for await (const file of glob.scan(cwd)) {
-        includedFiles.delete(file);
-      }
-    }
-  }
-  return Array.from(includedFiles);
-}
-var init_utils = __esm(() => {
-  init_errors();
-});
-
-// src/cli/utils.ts
-import pc8 from "picocolors";
-function displayBunupGradientArt() {
-  const art = `
-\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D 
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     
-\u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     
-	`.trim();
-  const lines = art.split(`
-`);
-  logger.space();
-  for (const line of lines) {
-    console.log(pc8.cyan(line));
-  }
-  logger.space();
-}
-var init_utils2 = __esm(() => {
-  init_logger();
-});
-
-// src/cli/new.ts
-var exports_new = {};
-__export(exports_new, {
-  newProject: () => newProject
-});
-import { renameSync } from "fs";
-import path5 from "path";
 import {
-  cancel,
-  confirm,
-  intro,
-  outro,
-  select,
-  tasks,
-  text
-} from "@clack/prompts";
-import { downloadTemplate } from "giget";
-import pc9 from "picocolors";
-import { replaceInFile } from "replace-in-file";
-async function newProject() {
-  displayBunupGradientArt();
-  intro(pc9.bgCyan(pc9.black(" Scaffold a new project with Bunup ")));
-  const selectedTemplateDir = await select({
-    message: "Select a template",
-    options: TEMPLATES.map((template2) => ({
-      value: template2.dir,
-      label: pc9.blue(template2.name)
-    }))
-  });
-  const template = TEMPLATES.find((t) => t.dir === selectedTemplateDir);
-  if (!template) {
-    cancel("Invalid template");
-    process.exit(1);
-  }
-  const hasMonorepo = template.monorepoDir !== undefined;
-  const projectName = await text({
-    message: "Enter the project name",
-    placeholder: template.defaultName,
-    defaultValue: template.defaultName,
-    validate: (value) => {
-      if (!value) {
-        return "Project name is required";
-      }
-      if (value.includes(" ")) {
-        return "Project name cannot contain spaces";
-      }
-      if (pathExistsSync(getProjectPath(value))) {
-        return "Project already exists";
-      }
-    }
-  });
-  const projectPath = getProjectPath(projectName);
-  let useMonorepo = false;
-  let monorepoFirstPackageName;
-  if (hasMonorepo) {
-    useMonorepo = await confirm({
-      message: "Do you want to create a monorepo?",
-      initialValue: false
-    });
-    if (useMonorepo) {
-      monorepoFirstPackageName = await text({
-        message: "Enter the name of the first package",
-        placeholder: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER,
-        defaultValue: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER
-      });
-    }
-  }
-  const githubRepoInfo = await text({
-    message: "GitHub username and repo name (username/repo):",
-    placeholder: `${GITHUB_USERNAME_PLACEHOLDER}/${GITHUB_REPO_PLACEHOLDER}`,
-    defaultValue: `${GITHUB_USERNAME_PLACEHOLDER}/${GITHUB_REPO_PLACEHOLDER}`
-  });
-  const [githubUsername, githubRepoName] = githubRepoInfo.split("/");
-  await tasks([
-    {
-      title: "Downloading template",
-      task: async () => {
-        const templatePath = useMonorepo ? template.monorepoDir : template.dir;
-        await downloadTemplate(`github:${TEMPLATE_OWNER}/${TEMPLATE_REPO}/${templatePath}`, {
-          dir: projectPath
-        });
-        return "Template downloaded";
-      }
-    },
-    {
-      title: "Making the project yours",
-      task: async () => {
-        await replaceInFile({
-          files: path5.join(projectPath, "**/*"),
-          from: [
-            new RegExp(GITHUB_REPO_PLACEHOLDER, "g"),
-            new RegExp(GITHUB_USERNAME_PLACEHOLDER, "g"),
-            new RegExp(template.defaultName, "g")
-          ],
-          to: [githubRepoName, githubUsername, projectName],
-          ignore: ["node_modules", "dist", "bun.lock"]
-        });
-        if (useMonorepo && monorepoFirstPackageName) {
-          await replaceInFile({
-            files: path5.join(projectPath, "**/*"),
-            from: [new RegExp(MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER, "g")],
-            to: [monorepoFirstPackageName],
-            ignore: ["node_modules", "dist", "bun.lock"]
-          });
-          renameSync(path5.join(projectPath, MONOREPO_PACKAGES_DIR, MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER), path5.join(projectPath, MONOREPO_PACKAGES_DIR, monorepoFirstPackageName));
-        }
-      }
-    }
-  ]);
-  outro(`
-   ${pc9.green("\u2728 Project scaffolded successfully! \u2728")}
-
-   ${pc9.bold("Ready to launch your awesome new project?")}
-
-   ${pc9.cyan("cd")} ${projectName}
-   ${pc9.cyan("bun install")}
-   ${pc9.cyan("bun run dev")}${pc9.dim(" (watch mode for development)")}${template.type === "react" ? `
-   ${pc9.cyan("bun run dev:test")} ${pc9.dim("(preview components in a test Next.js app)")} ` : ""}
-
-   ${pc9.dim("Learn more:")} ${pc9.underline("https://bunup.dev/docs")}
-
-   ${pc9.yellow("Happy coding!")} \uD83D\uDE80
-		`);
-}
-function getProjectPath(projectName) {
-  return path5.join(process.cwd(), projectName);
-}
-var TEMPLATE_OWNER = "arshad-yaseen", TEMPLATE_REPO = "bunup-new", GITHUB_USERNAME_PLACEHOLDER = "username", GITHUB_REPO_PLACEHOLDER = "repo-name", MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER = "package-1", MONOREPO_PACKAGES_DIR = "packages", TEMPLATES;
-var init_new = __esm(() => {
-  init_utils();
-  init_utils2();
-  TEMPLATES = [
-    {
-      type: "typescript",
-      defaultName: "my-ts-lib",
-      name: "Typescript Library",
-      dir: "ts-lib",
-      monorepoDir: "ts-lib-monorepo"
-    },
-    {
-      type: "react",
-      defaultName: "my-react-lib",
-      name: "React Library",
-      dir: "react-lib"
-    }
-  ];
-});
-
-// src/cli/init.ts
-var exports_init = {};
-__export(exports_init, {
-  init: () => init
-});
-import fs2 from "fs";
-import path6 from "path";
+  build,
+  createBuildOptions
+} from "../chunk-8zb11ewt.js";
+import"../chunk-6gvmfnmt.js";
 import {
-  confirm as confirm2,
-  intro as intro2,
-  log,
-  multiselect,
-  outro as outro2,
-  select as select2,
-  tasks as tasks2,
-  text as text2
-} from "@clack/prompts";
-import pc10 from "picocolors";
-import { exec } from "tinyexec";
-async function init() {
-  displayBunupGradientArt();
-  intro2(pc10.bgCyan(pc10.black(" Initialize bunup in an existing project ")));
-  const { path: packageJsonPath } = await loadPackageJson();
-  if (!packageJsonPath) {
-    log.error("package.json not found");
-    process.exit(1);
-  }
-  const shouldSetupWorkspace = await promptForWorkspace();
-  if (shouldSetupWorkspace) {
-    await initializeWorkspace(packageJsonPath);
-  } else {
-    await initializeSinglePackage(packageJsonPath);
-  }
-  await tasks2([
-    {
-      title: "Installing bunup",
-      task: async () => {
-        await installBunup();
-        return "Bunup installed";
-      }
-    }
-  ]);
-  showSuccessOutro(shouldSetupWorkspace);
-}
-async function promptForWorkspace() {
-  return await confirm2({
-    message: "Do you want to setup a Bunup workspace? (for building multiple packages with one command)",
-    initialValue: false
-  });
-}
-async function initializeWorkspace(packageJsonPath) {
-  const workspacePackages = await collectWorkspacePackages();
-  const configMethod = await selectWorkspaceConfigurationMethod();
-  await generateWorkspaceConfiguration(configMethod, workspacePackages);
-  await handleWorkspaceBuildScripts(packageJsonPath);
-}
-async function initializeSinglePackage(packageJsonPath) {
-  const entryFiles = await collectEntryFiles();
-  const outputFormats = await selectOutputFormats();
-  const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
-  const configMethod = await selectConfigurationMethod();
-  await generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath);
-  await handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod);
-}
-async function collectWorkspacePackages() {
-  const packages = [];
-  while (true) {
-    const packageName = await text2({
-      message: packages.length > 0 ? "Enter the next package name:" : "Enter the first package name:",
-      placeholder: "core",
-      validate: (value) => {
-        if (!value)
-          return "Package name is required";
-        if (packages.some((pkg) => pkg.name === value))
-          return "Package name already exists";
-      }
-    });
-    const packageRoot = await text2({
-      message: `Enter the root directory for "${packageName}":`,
-      placeholder: `packages/${packageName}`,
-      defaultValue: `packages/${packageName}`,
-      validate: (value) => {
-        if (!value)
-          return "Package root is required";
-        if (!fs2.existsSync(value))
-          return "Package root directory does not exist";
-        if (!fs2.statSync(value).isDirectory())
-          return "Package root must be a directory";
-      }
-    });
-    const entryFiles = await collectEntryFilesForPackage(packageRoot, packageName);
-    const outputFormats = await selectOutputFormats();
-    const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
-    packages.push({
-      name: packageName,
-      root: packageRoot,
-      entryFiles,
-      outputFormats,
-      shouldGenerateDts
-    });
-    const shouldAddMore = await confirm2({
-      message: "Do you want to add another package?",
-      initialValue: true
-    });
-    if (!shouldAddMore)
-      break;
-  }
-  return packages;
-}
-async function collectEntryFilesForPackage(packageRoot, packageName) {
-  const entryFiles = [];
-  while (true) {
-    const entryFile = await text2({
-      message: entryFiles.length > 0 ? `Where is the next entry file for "${packageName}"? (relative to ${packageRoot})` : `Where is the entry file for "${packageName}"? (relative to ${packageRoot})`,
-      placeholder: "src/index.ts",
-      defaultValue: "src/index.ts",
-      validate: (value) => {
-        if (!value)
-          return "Entry file is required";
-        const fullPath = path6.join(packageRoot, value);
-        if (!fs2.existsSync(fullPath))
-          return `Entry file does not exist at ${fullPath}`;
-        if (!fs2.statSync(fullPath).isFile())
-          return "Entry file must be a file";
-        if (entryFiles.includes(value))
-          return "You have already added this entry file";
-      }
-    });
-    entryFiles.push(entryFile);
-    const shouldAddMore = await confirm2({
-      message: "Do you want to add another entry file for this package?",
-      initialValue: false
-    });
-    if (!shouldAddMore)
-      break;
-  }
-  return entryFiles;
-}
-async function collectEntryFiles() {
-  const entryFiles = [];
-  while (true) {
-    const entryFile = await text2({
-      message: entryFiles.length > 0 ? "Where is your next entry file?" : "Where is your entry file?",
-      placeholder: "src/index.ts",
-      defaultValue: "src/index.ts",
-      validate: (value) => {
-        if (!value)
-          return "Entry file is required";
-        if (!fs2.existsSync(value))
-          return "Entry file does not exist";
-        if (!fs2.statSync(value).isFile())
-          return "Entry file must be a file";
-        if (entryFiles.includes(value))
-          return "You have already added this entry file";
-      }
-    });
-    entryFiles.push(entryFile);
-    const shouldAddMore = await confirm2({
-      message: "Do you want to add another entry file?",
-      initialValue: false
-    });
-    if (!shouldAddMore)
-      break;
-  }
-  return entryFiles;
-}
-async function selectOutputFormats() {
-  return await multiselect({
-    message: "Select the output formats",
-    options: [
-      { value: "esm", label: "ESM (.mjs)" },
-      { value: "cjs", label: "CommonJS (.cjs)" },
-      { value: "iife", label: "IIFE (.global.js)" }
-    ],
-    initialValues: ["esm", "cjs"]
-  });
-}
-async function promptForTypeScriptDeclarations(entryFiles) {
-  const hasTypeScriptFiles = entryFiles.some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
-  if (!hasTypeScriptFiles)
-    return false;
-  return await confirm2({
-    message: "Generate TypeScript declarations?",
-    initialValue: true
-  });
-}
-async function selectWorkspaceConfigurationMethod() {
-  return await select2({
-    message: "How would you like to configure your workspace?",
-    options: [
-      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
-      { value: "js", label: "bunup.config.js" }
-    ],
-    initialValue: "ts"
-  });
-}
-async function selectConfigurationMethod() {
-  return await select2({
-    message: "How would you like to configure Bunup?",
-    options: [
-      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
-      { value: "js", label: "bunup.config.js" },
-      { value: "json", label: 'package.json "bunup" property' },
-      {
-        value: "none",
-        label: "No config file",
-        hint: "Configure via CLI only"
-      }
-    ],
-    initialValue: "ts"
-  });
-}
-async function generateWorkspaceConfiguration(configMethod, workspacePackages) {
-  const configContent = createWorkspaceConfigFileContent(workspacePackages);
-  await Bun.write(`bunup.config.${configMethod}`, configContent);
-}
-async function generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath) {
-  if (configMethod === "none") {
-    log.info("If you need more control (such as adding plugins or customizing output), you can always create a config file later.");
-    return;
-  }
-  if (configMethod === "ts" || configMethod === "js") {
-    await Bun.write(`bunup.config.${configMethod}`, createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts));
-  } else if (configMethod === "json") {
-    const { data: packageJsonConfig } = await loadPackageJson();
-    const updatedConfig = {
-      ...packageJsonConfig,
-      bunup: createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts)
-    };
-    await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
-  }
-}
-async function handleWorkspaceBuildScripts(packageJsonPath) {
-  const { data: packageJsonConfig } = await loadPackageJson();
-  const existingScripts = packageJsonConfig?.scripts ?? {};
-  const newScripts = createWorkspaceBuildScripts();
-  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
-  if (conflictingScripts.length > 0) {
-    const shouldOverride = await confirm2({
-      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
-      initialValue: true
-    });
-    if (!shouldOverride) {
-      log.info("Skipped adding build scripts to avoid conflicts.");
-      return;
-    }
-  }
-  const updatedConfig = {
-    ...packageJsonConfig,
-    scripts: { ...existingScripts, ...newScripts }
-  };
-  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
-}
-async function handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod) {
-  const { data: packageJsonConfig } = await loadPackageJson();
-  const existingScripts = packageJsonConfig?.scripts ?? {};
-  const newScripts = createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod);
-  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
-  if (conflictingScripts.length > 0) {
-    const shouldOverride = await confirm2({
-      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
-      initialValue: true
-    });
-    if (!shouldOverride) {
-      log.info("Skipped adding build scripts to avoid conflicts.");
-      return;
-    }
-  }
-  const updatedConfig = {
-    ...packageJsonConfig,
-    scripts: { ...existingScripts, ...newScripts }
-  };
-  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
-}
-function createWorkspaceConfigFileContent(workspacePackages) {
-  const packagesConfig = workspacePackages.map((pkg) => {
-    return `  {
-    name: '${pkg.name}',
-    root: '${pkg.root}',
-    config: {
-      entry: [${pkg.entryFiles.map((file) => `'${file}'`).join(", ")}],
-      format: [${pkg.outputFormats.map((format) => `'${format}'`).join(", ")}],${pkg.shouldGenerateDts ? `
-      dts: true,` : ""}
-    },
-  }`;
-  }).join(`,
-`);
-  return `import { defineWorkspace } from 'bunup'
-
-export default defineWorkspace([
-${packagesConfig}
-])
-`;
-}
-function createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts) {
-  return `import { defineConfig } from 'bunup'
-
-export default defineConfig({
-	entry: [${entryFiles.map((file) => `'${file}'`).join(", ")}],
-	format: [${outputFormats.map((format) => `'${format}'`).join(", ")}],${shouldGenerateDts ? `
-	dts: true,` : ""}
-})
-`;
-}
-function createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts) {
-  return {
-    entry: entryFiles,
-    format: outputFormats,
-    ...shouldGenerateDts && { dts: true }
-  };
-}
-function createWorkspaceBuildScripts() {
-  return {
-    build: "bunup",
-    dev: "bunup --watch"
-  };
-}
-function createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod) {
-  const cliOptions = configMethod === "none" ? ` ${entryFiles.join(" ")} --format ${outputFormats.join(",")}${shouldGenerateDts ? " --dts" : ""}` : "";
-  return {
-    build: `bunup${cliOptions}`,
-    dev: `bunup${cliOptions} --watch`
-  };
-}
-function showSuccessOutro(isWorkspace) {
-  const buildCommand = isWorkspace ? `${pc10.cyan("bun run build")} - Build all packages in your workspace` : `${pc10.cyan("bun run build")} - Build your library`;
-  const devCommand = isWorkspace ? `${pc10.cyan("bun run dev")} - Start development mode (watches all packages)` : `${pc10.cyan("bun run dev")} - Start development mode`;
-  const filterCommand = isWorkspace ? `${pc10.cyan("bunup --filter core,utils")} - Build specific packages` : "";
-  outro2(`
-   ${pc10.green("\u2728 Bunup initialized successfully! \u2728")}
-
-   ${buildCommand}
-   ${devCommand}${isWorkspace ? `
-   ${filterCommand}` : ""}
-  
-   ${pc10.dim("Learn more:")} ${pc10.underline("https://bunup.dev/docs")}
-  
-   ${pc10.yellow("Happy building!")} \uD83D\uDE80
-  `);
-}
-async function installBunup() {
-  await exec("bun add -d bunup", [], {
-    nodeOptions: { shell: true, stdio: "pipe" }
-  });
-}
-var init_init = __esm(() => {
-  init_loaders();
-  init_utils();
-  init_utils2();
-});
+  processLoadedConfigs
+} from "../chunk-gh7z7s46.js";
+import {
+  BunupCLIError,
+  BunupWatchError,
+  __require,
+  __toESM,
+  ensureArray,
+  formatTime,
+  getShortFilePath,
+  handleError,
+  handleErrorAndExit,
+  logger,
+  parseErrorMessage,
+  setSilent
+} from "../chunk-c1eyecm3.js";
 
 // src/cli/index.ts
-import { exec as exec2 } from "tinyexec";
+import { exec } from "tinyexec";
 // package.json
-var version = "0.8.41";
-
-// src/cli/index.ts
-init_errors();
-init_logger();
+var version = "0.8.44";
 
 // src/cli/options.ts
-import pc3 from "picocolors";
+import pc from "picocolors";
 
 // src/constants/index.ts
 var BUNUP_DOCS_URL = "https://bunup.dev/docs";
 
 // src/cli/options.ts
-init_errors();
-init_logger();
 var createHandlers = () => ({
   boolean: (key) => (value, options) => {
     options[key] = value === true || value === "true";
@@ -1260,11 +348,11 @@ var displayHelp = () => {
     utility: "Utility Options"
   };
   console.log();
-  console.log(pc3.cyan(pc3.bold("bunup")));
+  console.log(pc.cyan(pc.bold("bunup")));
   console.log();
   console.log("\u26A1\uFE0F A blazing-fast build tool for your libraries built with Bun");
   console.log();
-  console.log(pc3.cyan("Usage:"));
+  console.log(pc.cyan("Usage:"));
   console.log("  bunup [entry...] [options]");
   console.log("  bunup --init");
   console.log("  bunup --new");
@@ -1273,24 +361,24 @@ var displayHelp = () => {
     const categoryOptions = Object.values(OPTION_DEFINITIONS).filter((option) => option.category === categoryKey);
     if (categoryOptions.length === 0)
       return;
-    console.log(pc3.cyan(`${categoryName}:`));
+    console.log(pc.cyan(`${categoryName}:`));
     for (const option of categoryOptions) {
       const flags = option.flags.map((flag) => flag.length === 1 ? `-${flag}` : `--${flag}`).join(", ");
-      const flagsDisplay = pc3.green(flags);
-      const typeDisplay = pc3.dim(`<${option.type}>`);
-      const defaultDisplay = option.default ? pc3.yellow(`(default: ${option.default})`) : "";
+      const flagsDisplay = pc.green(flags);
+      const typeDisplay = pc.dim(`<${option.type}>`);
+      const defaultDisplay = option.default ? pc.yellow(`(default: ${option.default})`) : "";
       console.log(`  ${flagsDisplay} ${typeDisplay}`);
-      console.log(`    ${pc3.dim(option.description)} ${defaultDisplay}`);
+      console.log(`    ${pc.dim(option.description)} ${defaultDisplay}`);
       console.log();
     }
   }
-  console.log(pc3.cyan("Examples:"));
+  console.log(pc.cyan("Examples:"));
   console.log("  bunup src/**/*.ts");
   console.log("  bunup src/index.ts src/cli.ts --format esm,cjs");
   console.log("  bunup src/index.ts --watch --dts");
   console.log();
-  console.log(pc3.dim("For more information:"));
-  console.log(`  ${pc3.cyan(pc3.underline(BUNUP_DOCS_URL))}`);
+  console.log(pc.dim("For more information:"));
+  console.log(`  ${pc.cyan(pc.underline(BUNUP_DOCS_URL))}`);
   console.log();
 };
 var parseArgument = (arg, nextArg) => {
@@ -1337,393 +425,19 @@ var parseCliOptions = (argv) => {
 };
 
 // src/cli/index.ts
-import { loadConfig as loadConfig2 } from "coffi";
-import pc11 from "picocolors";
-
-// src/build.ts
-init_errors();
-init_loaders();
-init_logger();
-import path3 from "path";
-import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
-import pc6 from "picocolors";
-
-// src/plugins/internal/report.ts
-init_logger();
-init_logger();
-init_utils();
-import pc4 from "picocolors";
-function report() {
-  return {
-    type: "bunup",
-    name: "report",
-    hooks: {
-      onBuildDone: async ({ options, output }) => {
-        if (options.watch)
-          return;
-        const files = await Promise.all(output.files.map(async (file) => {
-          const name = file.relativePathToRootDir;
-          const size = Bun.file(file.fullPath).size;
-          const gzipSize = Bun.gzipSync(new Uint8Array(await Bun.file(file.fullPath).arrayBuffer())).length;
-          const formattedGzipSize = formatFileSize(gzipSize);
-          return {
-            name,
-            size,
-            formattedSize: formatFileSize(size),
-            gzipSize,
-            formattedGzipSize
-          };
-        }));
-        const totalSize = files.reduce((sum, file) => sum + file.size, 0);
-        const formattedTotalSize = formatFileSize(totalSize);
-        const totalGzipSize = files.reduce((sum, file) => sum + (file.gzipSize || 0), 0);
-        const formattedTotalGzipSize = formatFileSize(totalGzipSize);
-        const columns = [
-          { header: "File", align: "left", color: pc4.blue },
-          { header: "Size", align: "right", color: pc4.green },
-          {
-            header: "Gzip",
-            align: "right",
-            color: pc4.magenta
-          }
-        ];
-        const data = files.map((file) => {
-          return {
-            File: file.name,
-            Size: file.formattedSize,
-            Gzip: file.formattedGzipSize
-          };
-        });
-        const footer = {
-          File: "Total",
-          Size: formattedTotalSize,
-          Gzip: formattedTotalGzipSize
-        };
-        logger.space();
-        logTable(columns, data, footer);
-        logger.space();
-      }
-    }
-  };
-}
-
-// src/plugins/internal/use-client.ts
-function useClient() {
-  return {
-    type: "bunup",
-    name: "use-client",
-    hooks: {
-      onBuildDone: async ({ output }) => {
-        for (const file of output.files) {
-          let text = await Bun.file(file.fullPath).text();
-          const hasUseClient = text.split(`
-`).some((line) => line.trim().startsWith(`"use client";`));
-          if (hasUseClient) {
-            text = text.replaceAll(`"use client";`, "");
-            text = `"use client";
-${text}`;
-          }
-          await Bun.write(file.fullPath, text);
-        }
-      }
-    }
-  };
-}
-
-// src/options.ts
-init_utils();
-var DEFAULT_OPTIONS = {
-  entry: [],
-  format: ["cjs"],
-  outDir: "dist",
-  target: "node",
-  clean: true
-};
-function createBuildOptions(partialOptions) {
-  const options = {
-    ...DEFAULT_OPTIONS,
-    ...partialOptions
-  };
-  return {
-    ...options,
-    plugins: [
-      ...options.plugins?.filter((p) => p.name !== "report") ?? [],
-      useClient(),
-      report()
-    ]
-  };
-}
-function getResolvedMinify(options) {
-  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
-  const defaultValue = minify === true;
-  return {
-    whitespace: minifyWhitespace ?? defaultValue,
-    identifiers: minifyIdentifiers ?? defaultValue,
-    syntax: minifySyntax ?? defaultValue
-  };
-}
-function getResolvedBytecode(bytecode, format) {
-  return format === "cjs" ? bytecode : undefined;
-}
-function getResolvedSourcemap(sourcemap) {
-  if (sourcemap === true) {
-    return "inline";
-  }
-  return typeof sourcemap === "string" ? sourcemap : undefined;
-}
-function getResolvedDefine(define, env) {
-  return {
-    ...typeof env === "object" && Object.keys(env).reduce((acc, key) => {
-      const value = JSON.stringify(env[key]);
-      acc[`process.env.${key}`] = value;
-      acc[`import.meta.env.${key}`] = value;
-      return acc;
-    }, {}),
-    ...define
-  };
-}
-function getResolvedSplitting(splitting, format) {
-  return splitting === undefined ? format === "esm" : splitting;
-}
-function getResolvedDtsSplitting(splitting) {
-  return splitting ?? true;
-}
-var DEFAULT_ENTRY_NAMING = "[dir]/[name].[ext]";
-function getResolvedNaming(fmt, packageType) {
-  const replaceExt = (pattern) => pattern.replace(".[ext]", getDefaultOutputExtension(fmt, packageType));
-  return replaceExt(DEFAULT_ENTRY_NAMING);
-}
-function getResolvedEnv(env) {
-  return typeof env === "string" ? env : undefined;
-}
-
-// src/helpers/external.ts
-init_utils();
-function getPackageDepsPatterns(packageJson) {
-  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
-}
-function matchesPattern(path3, pattern) {
-  return typeof pattern === "string" ? pattern === path3 : pattern.test(path3);
-}
-function isExternal(path3, options, packageJson) {
-  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
-  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path3)) || options.external?.some((pattern) => matchesPattern(path3, pattern));
-  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path3, pattern));
-  return matchesExternalPattern && !isExcludedFromExternal;
-}
-
-// src/plugins/internal/external-option.ts
-function externalOptionPlugin(options, packageJson) {
-  return {
-    name: "bunup:external-option-plugin",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, (args) => {
-        const importPath = args.path;
-        if (isExternal(importPath, options, packageJson)) {
-          return {
-            path: importPath,
-            external: true
-          };
-        }
-        return null;
-      });
-    }
-  };
-}
-
-// src/plugins/utils.ts
-init_errors();
-import pc5 from "picocolors";
-function filterBunupBunPlugins(plugins) {
-  if (!plugins)
-    return [];
-  return plugins.filter((p) => p.type === "bun");
-}
-function filterBunupPlugins(plugins) {
-  if (!plugins)
-    return [];
-  return plugins.filter((p) => p.type === "bunup");
-}
-async function runPluginBuildStartHooks(bunupPlugins, options) {
-  if (!bunupPlugins)
-    return;
-  for (const plugin of bunupPlugins) {
-    if (plugin.hooks.onBuildStart) {
-      await plugin.hooks.onBuildStart(options);
-    }
-  }
-}
-async function runPluginBuildDoneHooks(bunupPlugins, options, output, meta) {
-  if (!bunupPlugins)
-    return;
-  for (const plugin of bunupPlugins) {
-    if (plugin.hooks.onBuildDone) {
-      await plugin.hooks.onBuildDone({ options, output, meta });
-    }
-  }
-}
-async function getPackageForPlugin(name, pluginName) {
-  let pkg;
-  try {
-    pkg = await import(name);
-  } catch {
-    throw new BunupPluginError(`[${pc5.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc5.blue(`bun add ${name} --dev`)}`);
-  }
-  return pkg;
-}
-
-// src/build.ts
-init_utils();
-async function build(partialOptions, rootDir = process.cwd()) {
-  const buildOutput = {
-    files: []
-  };
-  const options = createBuildOptions(partialOptions);
-  if (!options.entry || options.entry.length === 0 || !options.outDir) {
-    throw new BunupBuildError("Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments.");
-  }
-  if (options.clean) {
-    cleanOutDir(rootDir, options.outDir);
-  }
-  setSilent(options.silent);
-  const packageJson = await loadPackageJson(rootDir);
-  if (packageJson.data && packageJson.path) {
-    logger.info(`Using ${getShortFilePath(packageJson.path, 2)}`, {
-      muted: true,
-      identifier: options.name,
-      once: `${packageJson.path}:${options.name}`
-    });
-  }
-  const bunupPlugins = filterBunupPlugins(options.plugins);
-  await runPluginBuildStartHooks(bunupPlugins, options);
-  const packageType = packageJson.data?.type;
-  const plugins = [
-    externalOptionPlugin(options, packageJson.data),
-    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
-  ];
-  const entrypoints = await getFilesFromGlobs(ensureArray(options.entry), rootDir);
-  if (!entrypoints.length) {
-    throw new BunupBuildError("The entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
-  }
-  const buildPromises = options.format.flatMap(async (fmt) => {
-    const result = await Bun.build({
-      entrypoints: entrypoints.map((file) => `${rootDir}/${file}`),
-      format: fmt,
-      naming: getResolvedNaming(fmt, packageType),
-      splitting: getResolvedSplitting(options.splitting, fmt),
-      bytecode: getResolvedBytecode(options.bytecode, fmt),
-      define: getResolvedDefine(options.define, options.env),
-      minify: getResolvedMinify(options),
-      outdir: `${rootDir}/${options.outDir}`,
-      target: options.target,
-      sourcemap: getResolvedSourcemap(options.sourcemap),
-      loader: options.loader,
-      drop: options.drop,
-      banner: options.banner,
-      footer: options.footer,
-      publicPath: options.publicPath,
-      env: getResolvedEnv(options.env),
-      ignoreDCEAnnotations: options.ignoreDCEAnnotations,
-      emitDCEAnnotations: options.emitDCEAnnotations,
-      throw: false,
-      plugins
-    });
-    for (const log of result.logs) {
-      if (log.level === "error") {
-        throw new BunupBuildError(log.message);
-      }
-      if (log.level === "warning")
-        logger.warn(log.message);
-      else if (log.level === "info")
-        logger.info(log.message);
-    }
-    for (const file of result.outputs) {
-      const relativePathToRootDir = getRelativePathToRootDir(file.path, rootDir);
-      const relativePathToOutputDir = getRelativePathToOutputDir(relativePathToRootDir, options.outDir);
-      if (file.kind === "entry-point") {
-        logger.success(`${pc6.dim(options.outDir)}/${relativePathToOutputDir}`, {
-          identifier: options.name
-        });
-      }
-      buildOutput.files.push({
-        fullPath: file.path,
-        relativePathToRootDir,
-        relativePathToOutputDir,
-        dts: false,
-        format: fmt,
-        kind: file.kind
-      });
-    }
-  });
-  await Promise.all(buildPromises);
-  if (options.dts) {
-    const { entry, splitting, ...dtsOptions } = typeof options.dts === "object" ? options.dts : {};
-    const dtsResult = await generateDts(ensureArray(entry ?? entrypoints), {
-      cwd: rootDir,
-      preferredTsConfigPath: options.preferredTsconfigPath,
-      splitting: getResolvedDtsSplitting(splitting),
-      ...dtsOptions
-    });
-    if (dtsResult.errors.length) {
-      logIsolatedDeclarationErrors(dtsResult.errors, {
-        shouldExit: true
-      });
-    }
-    for (const fmt of options.format) {
-      for (const file of dtsResult.files) {
-        const dtsExtension = getDefaultDtsExtention(fmt, packageType);
-        const relativePathToOutputDir = cleanPath(`${file.pathInfo.outputPathWithoutExtension}${dtsExtension}`);
-        const relativePathToRootDir = cleanPath(`${options.outDir}/${relativePathToOutputDir}`);
-        if (file.kind === "entry-point") {
-          logger.success(`${pc6.dim(options.outDir)}/${relativePathToOutputDir}`, {
-            identifier: options.name
-          });
-        }
-        const fullPath = path3.join(rootDir, relativePathToRootDir);
-        await Bun.write(fullPath, file.dts);
-        buildOutput.files.push({
-          fullPath,
-          relativePathToRootDir,
-          relativePathToOutputDir,
-          dts: true,
-          format: fmt,
-          kind: file.kind
-        });
-      }
-    }
-  }
-  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
-    packageJson,
-    rootDir
-  });
-  if (options.onSuccess) {
-    await options.onSuccess(options);
-  }
-}
-function getRelativePathToRootDir(filePath, rootDir) {
-  return cleanPath(filePath).replace(`${cleanPath(rootDir)}/`, "");
-}
-function getRelativePathToOutputDir(relativePathToRootDir, outDir) {
-  return cleanPath(relativePathToRootDir).replace(`${cleanPath(outDir)}/`, "");
-}
-
-// src/cli/index.ts
-init_loaders();
-init_utils();
+import { loadConfig } from "coffi";
+import pc3 from "picocolors";
 
 // src/watch.ts
-import path4 from "path";
-import pc7 from "picocolors";
-init_errors();
-init_logger();
-init_utils();
+import path from "path";
+import pc2 from "picocolors";
 async function watch(partialOptions, rootDir) {
   const watchPaths = new Set;
   const options = createBuildOptions(partialOptions);
   const uniqueEntries = new Set(options.entry);
   for (const entry of uniqueEntries) {
-    const entryPath = path4.resolve(rootDir, entry);
-    const parentDir = path4.dirname(entryPath);
+    const entryPath = path.resolve(rootDir, entry);
+    const parentDir = path.dirname(entryPath);
     watchPaths.add(parentDir);
   }
   const chokidar = await import("chokidar");
@@ -1733,7 +447,7 @@ async function watch(partialOptions, rootDir) {
     ignored: [
       /[\\/]\.git[\\/]/,
       /[\\/]node_modules[\\/]/,
-      path4.join(rootDir, options.outDir)
+      path.join(rootDir, options.outDir)
     ]
   });
   let isRebuilding = false;
@@ -1747,7 +461,7 @@ async function watch(partialOptions, rootDir) {
       const start = performance.now();
       await build(options, rootDir);
       if (!initial) {
-        logger.success(`\uD83D\uDCE6 Rebuild finished in ${pc7.green(formatTime(performance.now() - start))}`);
+        logger.success(`\uD83D\uDCE6 Rebuild finished in ${pc2.green(formatTime(performance.now() - start))}`);
       }
     } catch (error) {
       handleError(error);
@@ -1756,7 +470,7 @@ async function watch(partialOptions, rootDir) {
     }
   };
   watcher.on("change", (filePath) => {
-    const changedFile = path4.relative(rootDir, filePath);
+    const changedFile = path.relative(rootDir, filePath);
     logger.info(`File changed: ${changedFile}`, {
       muted: true,
       once: changedFile
@@ -1773,18 +487,18 @@ async function watch(partialOptions, rootDir) {
 async function main(args = Bun.argv.slice(2)) {
   const cliOptions = parseCliOptions(args);
   if (cliOptions.new) {
-    const { newProject: newProject2 } = await Promise.resolve().then(() => (init_new(), exports_new));
-    await newProject2();
+    const { newProject } = await import("../chunk-q3kvndyh.js");
+    await newProject();
     return;
   }
   if (cliOptions.init) {
-    const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
-    await init2();
+    const { init } = await import("../chunk-5s4mpe5d.js");
+    await init();
     return;
   }
   setSilent(cliOptions.silent);
   const cwd = process.cwd();
-  const { config, filepath } = await loadConfig2({
+  const { config, filepath } = await loadConfig({
     name: "bunup.config",
     extensions: [".ts", ".js", ".mjs", ".cjs"],
     maxDepth: 1,
@@ -1818,7 +532,7 @@ async function main(args = Bun.argv.slice(2)) {
   }));
   const buildTimeMs = performance.now() - startTime;
   const timeDisplay = formatTime(buildTimeMs);
-  logger.success(`Build completed in ${pc11.green(timeDisplay)}`);
+  logger.success(`Build completed in ${pc3.green(timeDisplay)}`);
   if (cliOptions.watch) {
     logger.info("\uD83D\uDC40 Watching for file changes");
   }
@@ -1826,7 +540,7 @@ async function main(args = Bun.argv.slice(2)) {
     logger.info(`Running command: ${cliOptions.onSuccess}`, {
       muted: true
     });
-    await exec2(cliOptions.onSuccess, [], {
+    await exec(cliOptions.onSuccess, [], {
       nodeOptions: { shell: true, stdio: "inherit" }
     });
   }