bunup 0.8.29 → 0.8.30

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createRequire } from "node:module";
+// @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -16,6 +16,17 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+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;
 
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -87,26 +98,7 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
-// src/define.ts
-function defineConfig(options) {
-  return options;
-}
-function defineWorkspace(options) {
-  return options;
-}
-// src/build.ts
-import path4 from "node:path";
-import {
-  generateDts,
-  logIsolatedDeclarationErrors
-} from "bun-dts";
-
-// src/errors.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
-
 // src/logger.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-var silent = false;
 function setSilent(value) {
   silent = value ?? false;
 }
@@ -291,40 +283,140 @@ function logTable(columns, data, footer) {
     console.log(footerRow);
   }
 }
-var logger = Logger.getInstance();
+var import_picocolors, silent = false, logger;
+var init_logger = __esm(() => {
+  import_picocolors = __toESM(require_picocolors(), 1);
+  logger = Logger.getInstance();
+});
 
 // src/errors.ts
-class BunupError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BunupError";
-  }
-}
-
-class BunupBuildError extends BunupError {
-  constructor(message) {
-    super(message);
-    this.name = "BunupBuildError";
-  }
-}
-
-class BunupDTSBuildError extends BunupError {
-  constructor(message) {
-    super(message);
-    this.name = "BunupDTSBuildError";
-  }
-}
-var parseErrorMessage = (error) => {
+var import_picocolors2, 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(`${import_picocolors2.default.red(errorType)} ${contextPrefix}${errorMessage}`);
+  }
+  if (knownError) {
+    console.log(`
+`);
+    knownError.logSolution(errorMessage);
+    console.log(`
+`);
+  } else {
+    console.error(import_picocolors2.default.dim(import_picocolors2.default.white("If you think this is a bug, please open an issue at: ") + import_picocolors2.default.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
+  }
+}, handleErrorAndExit = (error, context) => {
+  handleError(error, context);
+  process.exit(1);
 };
+var init_errors = __esm(() => {
+  import_picocolors2 = __toESM(require_picocolors(), 1);
+  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.error(import_picocolors2.default.white("You're trying to build a project that uses Bun. ") + import_picocolors2.default.white("Please set the target option to ") + import_picocolors2.default.cyan("`bun`") + import_picocolors2.default.white(`.
+`) + import_picocolors2.default.white("Example: ") + import_picocolors2.default.green("`bunup --target bun`") + import_picocolors2.default.white(" or in config: ") + import_picocolors2.default.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 "node:fs";
-import fs from "node:fs/promises";
-import path, { normalize } from "node:path";
+import fsSync from "fs";
+import fs from "fs/promises";
+import path2, { normalize } from "path";
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 function getDefaultJsOutputExtension(format, packageType) {
   switch (format) {
     case "esm":
@@ -335,25 +427,22 @@ function getDefaultJsOutputExtension(format, packageType) {
       return ".global.js";
   }
 }
-function getDefaultDtsOutputExtension(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 removeExtension(filePath) {
-  return filePath.replace(path.extname(filePath), "");
-}
-function cleanPath(filePath) {
-  return filePath.replace(/\\/g, "/");
+  const basename = path2.basename(filePath);
+  const firstDotIndex = basename.indexOf(".");
+  if (firstDotIndex === -1) {
+    return filePath;
+  }
+  const nameWithoutExtensions = basename.slice(0, firstDotIndex);
+  const directory = path2.dirname(filePath);
+  return directory === "." ? nameWithoutExtensions : path2.join(directory, nameWithoutExtensions);
 }
 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 [];
@@ -377,7 +466,7 @@ function getShortFilePath(filePath, maxLength = 3) {
   return shortPath;
 }
 async function cleanOutDir(rootDir, outDir) {
-  const outDirPath = path.join(rootDir, outDir);
+  const outDirPath = path2.join(rootDir, outDir);
   try {
     await fs.rm(outDirPath, { recursive: true, force: true });
   } catch (error) {
@@ -385,54 +474,67 @@ async function cleanOutDir(rootDir, outDir) {
   }
   await fs.mkdir(outDirPath, { recursive: true });
 }
-
-// src/helpers/entry.ts
-function getProcessableEntries(entry) {
-  if (typeof entry === "string") {
-    return [
-      {
-        entry,
-        outputBasePath: getEntryOutputBasePath(entry)
-      }
-    ];
-  }
-  if (typeof entry === "object" && !Array.isArray(entry)) {
-    return Object.entries(entry).map(([name, path2]) => ({
-      entry: path2,
-      outputBasePath: name
-    }));
+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;
   }
-  return entry.map((_entry) => ({
-    entry: _entry,
-    outputBasePath: getEntryOutputBasePath(_entry)
-  }));
 }
-function getEntryOutputBasePath(entry) {
-  const pathSegments = cleanPath(removeExtension(entry)).split("/");
-  return pathSegments.length > 1 ? pathSegments.slice(1).join("/") : pathSegments.join("/");
+function formatListWithAnd(arr) {
+  return new Intl.ListFormat("en", {
+    style: "long",
+    type: "conjunction"
+  }).format(arr);
 }
-function getResolvedNaming(outputBasePath, extension) {
-  return {
-    entry: `[dir]/${outputBasePath}${extension}`,
-    chunk: `${outputBasePath}-[hash].[ext]`,
-    asset: `${outputBasePath}-[name]-[hash].[ext]`
-  };
+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/loaders.ts
-import path2 from "node:path";
-import { loadConfig } from "coffi";
-async function loadPackageJson(cwd = process.cwd()) {
-  const { config, filepath } = await loadConfig({
-    name: "package",
-    cwd,
-    extensions: [".json"]
-  });
-  return {
-    data: config,
-    path: filepath
-  };
+// src/define.ts
+function defineConfig(options) {
+  return options;
 }
+function defineWorkspace(options) {
+  return options;
+}
+// src/build.ts
+init_errors();
+init_loaders();
+init_logger();
+import path4 from "path";
+import { dts } from "bun-dts";
 
 // src/constants/re.ts
 var JS_RE = /\.(js|jsx|cjs|mjs)$/;
@@ -440,11 +542,166 @@ var TS_RE = /\.(ts|tsx|mts|cts)$/;
 var DTS_RE = /\.(d\.(ts|mts|cts))$/;
 var JS_TS_RE = new RegExp(`${JS_RE.source}|${TS_RE.source}`);
 var JS_DTS_RE = new RegExp(`${JS_RE.source}|${DTS_RE.source}`);
+var CSS_RE = /\.(css)$/;
+
+// src/plugins/built-in/node/shims.ts
+function shims() {
+  return {
+    type: "bun",
+    name: "shims",
+    plugin: {
+      name: "bunup:shims",
+      setup(build) {
+        const isNodeCompatibleTarget = build.config.target === "node" || build.config.target === "bun";
+        const isEsm = build.config.format === "esm";
+        const isCjs = build.config.format === "cjs";
+        if (!isNodeCompatibleTarget || !isEsm && !isCjs) {
+          return;
+        }
+        build.config.define = {
+          ...build.config.define,
+          ...isCjs && {
+            "import.meta.url": "importMetaUrl"
+          }
+        };
+        build.onLoad({ filter: JS_TS_RE }, async ({ path: path2 }) => {
+          const content = await Bun.file(path2).text();
+          let shimCode = "";
+          if (isEsm && (/\b__dirname\b/.test(content) || /\b__filename\b/.test(content))) {
+            shimCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+`;
+          }
+          if (isCjs && /\bimport\.meta\.url\b/.test(content)) {
+            shimCode = `import { pathToFileURL } from 'url';
+
+const importMetaUrl = pathToFileURL(__filename).href;
+
+`;
+          }
+          if (!shimCode)
+            return;
+          const lines = content.split(`
+`);
+          const firstLine = lines[0];
+          const restLines = lines.slice(1);
+          return {
+            contents: [firstLine, shimCode, ...restLines].join(`
+`)
+          };
+        });
+      }
+    }
+  };
+}
+// src/plugins/built-in/productivity/exports.ts
+init_logger();
+init_utils();
+function exports(options = {}) {
+  return {
+    type: "bunup",
+    name: "exports",
+    hooks: {
+      onBuildDone: async ({ output, options: buildOptions, meta }) => {
+        if (!meta.packageJson.path || !meta.packageJson.data) {
+          return;
+        }
+        try {
+          const { exportsField, entryPoints } = generateExportsFields(output.files);
+          const files = Array.isArray(meta.packageJson.data.files) ? [
+            ...new Set([
+              ...meta.packageJson.data.files,
+              buildOptions.outDir
+            ])
+          ] : [buildOptions.outDir];
+          const mergedExports = { ...exportsField };
+          if (options.extraExports) {
+            for (const [key, value] of Object.entries(options.extraExports)) {
+              if (typeof value === "string") {
+                mergedExports[key] = value;
+              } else {
+                const existingExport = mergedExports[key];
+                if (typeof existingExport === "object" && existingExport !== null) {
+                  mergedExports[key] = {
+                    ...existingExport,
+                    ...value
+                  };
+                } else {
+                  mergedExports[key] = value;
+                }
+              }
+            }
+          }
+          const newPackageJson = {
+            name: meta.packageJson.data.name,
+            description: meta.packageJson.data.description,
+            version: meta.packageJson.data.version,
+            type: meta.packageJson.data.type,
+            private: meta.packageJson.data.private,
+            files,
+            ...entryPoints,
+            exports: mergedExports
+          };
+          for (const key in meta.packageJson.data) {
+            if (Object.prototype.hasOwnProperty.call(meta.packageJson.data, key) && !Object.prototype.hasOwnProperty.call(newPackageJson, key)) {
+              newPackageJson[key] = meta.packageJson.data[key];
+            }
+          }
+          await Bun.write(meta.packageJson.path, JSON.stringify(newPackageJson, null, 2));
+          logger.cli("Updated package.json with exports");
+        } catch {
+          logger.error("Failed to update package.json");
+        }
+      }
+    }
+  };
+}
+function generateExportsFields(files) {
+  const exportsField = {};
+  const entryPoints = {};
+  const filteredFiles = filterFiles(files);
+  for (const file of filteredFiles) {
+    const exportType = formatToExportField(file.format, file.dts);
+    const relativePath = `./${cleanPath(file.relativePathToRootDir)}`;
+    const exportKey = getExportKey(cleanPath(file.relativePathToOutputDir));
+    exportsField[exportKey] = {
+      ...exportsField[exportKey],
+      [exportType]: relativePath
+    };
+  }
+  for (const field of Object.keys(exportsField["."] ?? {})) {
+    const entryPoint = exportFieldToEntryPoint(field);
+    entryPoints[entryPoint] = exportsField["."][field];
+  }
+  return { exportsField, entryPoints };
+}
+function filterFiles(files) {
+  return files.filter((file) => JS_DTS_RE.test(file.fullPath) && file.kind === "entry-point");
+}
+function getExportKey(relativePathToOutputDir) {
+  const pathSegments = cleanPath(removeExtension(relativePathToOutputDir)).split("/");
+  if (pathSegments.length === 1 && pathSegments[0].startsWith("index")) {
+    return ".";
+  }
+  return `./${pathSegments.filter((p) => !p.startsWith("index")).join("/")}`;
+}
+function exportFieldToEntryPoint(exportField) {
+  return exportField === "types" ? "types" : exportField === "require" ? "main" : "module";
+}
+function formatToExportField(format, dts) {
+  return dts ? "types" : format === "esm" ? "import" : "require";
+}
 // src/plugins/built-in/css/inject-styles.ts
-import path3 from "node:path";
+import path3 from "path";
+init_logger();
 
 // src/plugins/utils.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
+init_errors();
 function filterBunupBunPlugins(plugins) {
   if (!plugins)
     return [];
@@ -473,11 +730,104 @@ async function runPluginBuildDoneHooks(bunupPlugins, options, output, meta) {
     }
   }
 }
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  try {
+    pkg = await import(name);
+  } catch {
+    throw new BunupPluginError(`[${import_picocolors3.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors3.default.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+// src/plugins/built-in/css/inject-styles.ts
+function injectStyles(options) {
+  const { inject, ...transformOptions } = options ?? {};
+  return {
+    type: "bun",
+    name: "inject-styles",
+    plugin: {
+      name: "bunup:inject-styles",
+      async setup(build) {
+        const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
+        build.onResolve({ filter: /^__inject-style$/ }, () => {
+          return {
+            path: "__inject-style",
+            namespace: "__inject-style"
+          };
+        });
+        build.onLoad({ filter: /^__inject-style$/, namespace: "__inject-style" }, () => {
+          return {
+            contents: `
+                      export default function injectStyle(css) {
+                        if (!css || typeof document === 'undefined') return
+                      
+                        const head = document.head || document.getElementsByTagName('head')[0]
+                        const style = document.createElement('style')
+                        head.appendChild(style)
+
+                        if (style.styleSheet) {
+                          style.styleSheet.cssText = css
+                        } else {
+                          style.appendChild(document.createTextNode(css))
+                        }
+                      }
+                      `,
+            loader: "js"
+          };
+        });
+        build.onLoad({ filter: CSS_RE }, async (args) => {
+          const source = await Bun.file(args.path).text();
+          const { code, warnings } = lightningcss.transform({
+            ...transformOptions,
+            filename: path3.basename(args.path),
+            code: Buffer.from(source),
+            minify: transformOptions.minify ?? (build.config.minify === true || typeof build.config.minify === "object" && build.config.minify.whitespace)
+          });
+          for (const warning of warnings) {
+            logger.warn(warning.message);
+          }
+          const stringifiedCode = JSON.stringify(code.toString());
+          const js = inject ? await inject(stringifiedCode, args.path) : `import injectStyle from '__inject-style';injectStyle(${stringifiedCode})`;
+          return {
+            contents: js,
+            loader: "js"
+          };
+        });
+      }
+    }
+  };
+}
 // src/plugins/built-in/productivity/copy.ts
-import { join } from "node:path";
-import { basename } from "node:path";
+init_utils();
+import { join } from "path";
+import { basename } from "path";
+function copy(patterns, outPath) {
+  return {
+    type: "bunup",
+    name: "copy",
+    hooks: {
+      onBuildDone: async ({ options, meta }) => {
+        const destinationPath = outPath || options.outDir;
+        for (const pattern of patterns) {
+          const glob = new Bun.Glob(pattern);
+          for await (const filePath of glob.scan({
+            cwd: meta.rootDir,
+            dot: true
+          })) {
+            const sourceFile = Bun.file(join(meta.rootDir, filePath));
+            await Bun.write(outPath && isDirectoryPath(outPath) ? join(destinationPath, basename(filePath)) : destinationPath, sourceFile);
+          }
+        }
+      }
+    }
+  };
+}
 // src/plugins/internal/report.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
+init_logger();
+init_logger();
+init_utils();
 function report() {
   return {
     type: "bunup",
@@ -555,6 +905,7 @@ ${text}`;
 }
 
 // src/options.ts
+init_utils();
 var DEFAULT_OPTIONS = {
   entry: [],
   format: ["cjs"],
@@ -608,11 +959,24 @@ function getResolvedDefine(define, env) {
 function getResolvedSplitting(splitting, format) {
   return splitting === undefined ? format === "esm" : splitting;
 }
+var DEFAULT_ENTRY_NAMING = "[dir]/[name].[ext]";
+function getResolvedNaming(naming, fmt, packageType) {
+  const resolvedNaming = typeof naming === "object" ? { entry: DEFAULT_ENTRY_NAMING, ...naming } : naming ?? DEFAULT_ENTRY_NAMING;
+  const replaceExt = (pattern) => pattern.replace(".[ext]", getDefaultJsOutputExtension(fmt, packageType));
+  if (typeof resolvedNaming === "string") {
+    return replaceExt(resolvedNaming);
+  }
+  return {
+    ...resolvedNaming,
+    entry: replaceExt(resolvedNaming.entry)
+  };
+}
 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}($|\\/|\\\\)`));
 }
@@ -646,6 +1010,7 @@ function externalOptionPlugin(options, packageJson) {
 }
 
 // src/build.ts
+init_utils();
 async function build(partialOptions, rootDir = process.cwd()) {
   const buildOutput = {
     files: []
@@ -668,113 +1033,98 @@ async function build(partialOptions, rootDir = process.cwd()) {
   }
   const bunupPlugins = filterBunupPlugins(options.plugins);
   await runPluginBuildStartHooks(bunupPlugins, options);
-  const processableEntries = getProcessableEntries(options.entry);
   const packageType = packageJson.data?.type;
   const plugins = [
     externalOptionPlugin(options, packageJson.data),
     ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
   ];
-  if (!options.dtsOnly) {
-    const buildPromises = options.format.flatMap((fmt) => processableEntries.map(async ({ entry, outputBasePath }) => {
-      const extension = options.outputExtension?.({
-        format: fmt,
-        packageType,
-        options,
-        entry
-      }).js ?? getDefaultJsOutputExtension(fmt, packageType);
-      const result = await Bun.build({
-        entrypoints: [`${rootDir}/${entry}`],
-        format: fmt,
-        naming: getResolvedNaming(outputBasePath, extension),
-        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),
-        plugins,
-        throw: false
-      });
-      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);
-        if (file.kind === "entry-point") {
-          logger.progress(fmt.toUpperCase(), relativePathToRootDir, {
+  if (options.dts) {
+    const { resolve, entry, splitting } = typeof options.dts === "object" ? options.dts : {};
+    let entrypoints2;
+    if (entry) {
+      entrypoints2 = await getFilesFromGlobs(ensureArray(entry), rootDir);
+    }
+    if (Array.isArray(entrypoints2) && !entrypoints2.length) {
+      throw new BunupDTSBuildError("The dts entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
+    }
+    plugins.push(dts({
+      resolve,
+      preferredTsConfigPath: options.preferredTsconfigPath,
+      entry: entrypoints2,
+      cwd: rootDir,
+      splitting,
+      onDeclarationsGenerated({ results, buildConfig }) {
+        for (const result of results) {
+          logger.progress("DTS", `${options.outDir}/${result.outputPath}`, {
             identifier: options.name
           });
+          const fullPath = path4.join(rootDir, options.outDir, result.outputPath);
+          if (buildConfig.format) {
+            buildOutput.files.push({
+              fullPath,
+              relativePathToRootDir: getRelativePathToRootDir(fullPath, rootDir),
+              relativePathToOutputDir: result.outputPath,
+              dts: true,
+              format: buildConfig.format,
+              kind: result.kind
+            });
+          }
         }
-        buildOutput.files.push({
-          fullPath: file.path,
-          relativePathToRootDir,
-          dts: false,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
       }
     }));
-    await Promise.all(buildPromises);
-  }
-  if (options.dts === true || typeof options.dts === "object" || options.dtsOnly) {
-    const dtsResolve = typeof options.dts === "object" && "resolve" in options.dts ? options.dts.resolve : undefined;
-    const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
-    const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : processableEntries;
-    const dtsPromises = processableDtsEntries.map(async ({ entry, outputBasePath }) => {
-      let result;
-      try {
-        result = await generateDts(entry, {
-          cwd: rootDir,
-          preferredTsConfigPath: options.preferredTsconfigPath,
-          resolve: dtsResolve
-        });
-      } catch (error) {
-        throw new BunupDTSBuildError(parseErrorMessage(error));
+  }
+  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(options.naming, 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),
+      plugins,
+      throw: false
+    });
+    for (const log of result.logs) {
+      if (log.level === "error") {
+        throw new BunupBuildError(log.message);
       }
-      for (const fmt of options.format) {
-        const extension = options.outputExtension?.({
-          format: fmt,
-          packageType,
-          options,
-          entry
-        }).dts ?? getDefaultDtsOutputExtension(fmt, packageType);
-        const filePath = path4.join(rootDir, options.outDir, `${outputBasePath}${extension}`);
-        const relativePathToRootDir = getRelativePathToRootDir(filePath, rootDir);
-        buildOutput.files.push({
-          fullPath: filePath,
-          relativePathToRootDir,
-          dts: true,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
-        if (result.errors.length > 0) {
-          logIsolatedDeclarationErrors(result.errors, {
-            shouldExit: true
-          });
-        }
-        await Bun.write(filePath, result.dts);
-        logger.progress("DTS", relativePathToRootDir, {
+      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);
+      if (file.kind === "entry-point") {
+        logger.progress(fmt.toUpperCase(), relativePathToRootDir, {
           identifier: options.name
         });
       }
-    });
-    await Promise.all(dtsPromises);
-  }
+      buildOutput.files.push({
+        fullPath: file.path,
+        relativePathToRootDir,
+        relativePathToOutputDir: getRelativePathToOutputDir(relativePathToRootDir, options.outDir),
+        dts: false,
+        format: fmt,
+        kind: file.kind
+      });
+    }
+  });
+  await Promise.all(buildPromises);
   await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
     packageJson,
     rootDir
@@ -784,7 +1134,10 @@ async function build(partialOptions, rootDir = process.cwd()) {
   }
 }
 function getRelativePathToRootDir(filePath, rootDir) {
-  return filePath.replace(`${rootDir}/`, "");
+  return cleanPath(filePath).replace(`${cleanPath(rootDir)}/`, "");
+}
+function getRelativePathToOutputDir(relativePathToRootDir, outDir) {
+  return cleanPath(relativePathToRootDir).replace(`${cleanPath(outDir)}/`, "");
 }
 export {
   defineWorkspace,