bunup 0.8.41 → 0.8.42

package/dist/cli/index.js

@@ -1,40 +1,952 @@
 #!/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 {
-  build,
-  createBuildOptions
-} from "../chunk-5ng6vk19.js";
-import"../plugins/index.js";
-import {
-  processLoadedConfigs
-} from "../chunk-gh7z7s46.js";
+  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";
 import {
-  BunupCLIError,
-  BunupWatchError,
-  __require,
-  __toESM,
-  ensureArray,
-  formatTime,
-  getShortFilePath,
-  handleError,
-  handleErrorAndExit,
-  logger,
-  parseErrorMessage,
-  setSilent
-} from "../chunk-c1eyecm3.js";
+  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();
+});
 
 // src/cli/index.ts
-import { exec } from "tinyexec";
+import { exec as exec2 } from "tinyexec";
 // package.json
-var version = "0.8.39";
+var version = "0.8.41";
+
+// src/cli/index.ts
+init_errors();
+init_logger();
 
 // src/cli/options.ts
-import pc from "picocolors";
+import pc3 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";
@@ -348,11 +1260,11 @@ var displayHelp = () => {
     utility: "Utility Options"
   };
   console.log();
-  console.log(pc.cyan(pc.bold("bunup")));
+  console.log(pc3.cyan(pc3.bold("bunup")));
   console.log();
   console.log("\u26A1\uFE0F A blazing-fast build tool for your libraries built with Bun");
   console.log();
-  console.log(pc.cyan("Usage:"));
+  console.log(pc3.cyan("Usage:"));
   console.log("  bunup [entry...] [options]");
   console.log("  bunup --init");
   console.log("  bunup --new");
@@ -361,24 +1273,24 @@ var displayHelp = () => {
     const categoryOptions = Object.values(OPTION_DEFINITIONS).filter((option) => option.category === categoryKey);
     if (categoryOptions.length === 0)
       return;
-    console.log(pc.cyan(`${categoryName}:`));
+    console.log(pc3.cyan(`${categoryName}:`));
     for (const option of categoryOptions) {
       const flags = option.flags.map((flag) => flag.length === 1 ? `-${flag}` : `--${flag}`).join(", ");
-      const flagsDisplay = pc.green(flags);
-      const typeDisplay = pc.dim(`<${option.type}>`);
-      const defaultDisplay = option.default ? pc.yellow(`(default: ${option.default})`) : "";
+      const flagsDisplay = pc3.green(flags);
+      const typeDisplay = pc3.dim(`<${option.type}>`);
+      const defaultDisplay = option.default ? pc3.yellow(`(default: ${option.default})`) : "";
       console.log(`  ${flagsDisplay} ${typeDisplay}`);
-      console.log(`    ${pc.dim(option.description)} ${defaultDisplay}`);
+      console.log(`    ${pc3.dim(option.description)} ${defaultDisplay}`);
       console.log();
     }
   }
-  console.log(pc.cyan("Examples:"));
+  console.log(pc3.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(pc.dim("For more information:"));
-  console.log(`  ${pc.cyan(pc.underline(BUNUP_DOCS_URL))}`);
+  console.log(pc3.dim("For more information:"));
+  console.log(`  ${pc3.cyan(pc3.underline(BUNUP_DOCS_URL))}`);
   console.log();
 };
 var parseArgument = (arg, nextArg) => {
@@ -425,19 +1337,393 @@ var parseCliOptions = (argv) => {
 };
 
 // src/cli/index.ts
-import { loadConfig } from "coffi";
-import pc3 from "picocolors";
+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();
 
 // src/watch.ts
-import path from "path";
-import pc2 from "picocolors";
+import path4 from "path";
+import pc7 from "picocolors";
+init_errors();
+init_logger();
+init_utils();
 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 = path.resolve(rootDir, entry);
-    const parentDir = path.dirname(entryPath);
+    const entryPath = path4.resolve(rootDir, entry);
+    const parentDir = path4.dirname(entryPath);
     watchPaths.add(parentDir);
   }
   const chokidar = await import("chokidar");
@@ -447,7 +1733,7 @@ async function watch(partialOptions, rootDir) {
     ignored: [
       /[\\/]\.git[\\/]/,
       /[\\/]node_modules[\\/]/,
-      path.join(rootDir, options.outDir)
+      path4.join(rootDir, options.outDir)
     ]
   });
   let isRebuilding = false;
@@ -461,7 +1747,7 @@ async function watch(partialOptions, rootDir) {
       const start = performance.now();
       await build(options, rootDir);
       if (!initial) {
-        logger.success(`\uD83D\uDCE6 Rebuild finished in ${pc2.green(formatTime(performance.now() - start))}`);
+        logger.success(`\uD83D\uDCE6 Rebuild finished in ${pc7.green(formatTime(performance.now() - start))}`);
       }
     } catch (error) {
       handleError(error);
@@ -470,7 +1756,7 @@ async function watch(partialOptions, rootDir) {
     }
   };
   watcher.on("change", (filePath) => {
-    const changedFile = path.relative(rootDir, filePath);
+    const changedFile = path4.relative(rootDir, filePath);
     logger.info(`File changed: ${changedFile}`, {
       muted: true,
       once: changedFile
@@ -487,18 +1773,18 @@ async function watch(partialOptions, rootDir) {
 async function main(args = Bun.argv.slice(2)) {
   const cliOptions = parseCliOptions(args);
   if (cliOptions.new) {
-    const { newProject } = await import("../chunk-q3kvndyh.js");
-    await newProject();
+    const { newProject: newProject2 } = await Promise.resolve().then(() => (init_new(), exports_new));
+    await newProject2();
     return;
   }
   if (cliOptions.init) {
-    const { init } = await import("../chunk-5s4mpe5d.js");
-    await init();
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+    await init2();
     return;
   }
   setSilent(cliOptions.silent);
   const cwd = process.cwd();
-  const { config, filepath } = await loadConfig({
+  const { config, filepath } = await loadConfig2({
     name: "bunup.config",
     extensions: [".ts", ".js", ".mjs", ".cjs"],
     maxDepth: 1,
@@ -532,7 +1818,7 @@ async function main(args = Bun.argv.slice(2)) {
   }));
   const buildTimeMs = performance.now() - startTime;
   const timeDisplay = formatTime(buildTimeMs);
-  logger.success(`Build completed in ${pc3.green(timeDisplay)}`);
+  logger.success(`Build completed in ${pc11.green(timeDisplay)}`);
   if (cliOptions.watch) {
     logger.info("\uD83D\uDC40 Watching for file changes");
   }
@@ -540,7 +1826,7 @@ async function main(args = Bun.argv.slice(2)) {
     logger.info(`Running command: ${cliOptions.onSuccess}`, {
       muted: true
     });
-    await exec(cliOptions.onSuccess, [], {
+    await exec2(cliOptions.onSuccess, [], {
       nodeOptions: { shell: true, stdio: "inherit" }
     });
   }