bunup 0.1.0 → 0.1.3

package/build/cli.js

@@ -1,5 +1,827 @@
 #!/usr/bin/env bun
-'use strict';function u(t){console.log(`\x1B[32m[INFO]\x1B[0m ${t}`);}function x(t){console.warn(`\x1B[33m[WARN]\x1B[0m ${t}`);}function l(t){console.error(`\x1B[31m[ERROR]\x1B[0m ${t}`);}var m={entry:["src/index.ts"],format:["esm"],outdir:"dist",minify:false,minifyIdentifiers:false,minifySyntax:false,minifyWhitespace:false,watch:false,dts:false,external:[]},O=(t,n)=>({entrypoints:t.entry.map(e=>`${n}/${e}`),outdir:`${n}/${t.outdir}`,format:t.format[0],minify:$(t),external:t.external||["node_modules/*"]});function $(t){return {whitespace:t.minifyWhitespace!==void 0?t.minifyWhitespace:t.minify??false,identifiers:t.minifyIdentifiers!==void 0?t.minifyIdentifiers:t.minify??false,syntax:t.minifySyntax!==void 0?t.minifySyntax:t.minify??false}}async function d(t,n,e=false){let i=O(t,n);if(e)u(`Watching ${n}...`),Bun.spawn(["bun","build",...i.entrypoints||[],"--outdir",i.outdir||"","--watch"],{stdout:"inherit",stderr:"inherit"});else {for(let o of t.format){let r=await Bun.build({...i,format:o});r.success||(l("Build failed:"),r.logs.forEach(s=>console.error(s)),process.exit(1));}t.dts&&(u("Generating .d.ts files..."),await Bun.spawn(["tsc","--emitDeclarationOnly","--outDir",`${n}/${t.outdir}`]).exited),u(`Built to ${t.outdir}`);}}var E={f:"format",o:"outdir",m:"minify",w:"watch",d:"dts",e:"external",mw:"minifyWhitespace",mi:"minifyIdentifiers",ms:"minifySyntax"},T={format:(t,n)=>{n.format=t.split(",");},outdir:(t,n)=>{n.outdir=t;},minify:(t,n)=>{n.minify=!!t;},watch:(t,n)=>{n.watch=!!t;},dts:(t,n)=>{n.dts=!!t;},external:(t,n)=>{n.external=t.split(",");},minifyWhitespace:(t,n)=>{n.minifyWhitespace=!!t;},minifyIdentifiers:(t,n)=>{n.minifyIdentifiers=!!t;},minifySyntax:(t,n)=>{n.minifySyntax=!!t;}};function h(t){let n={entry:[]};for(let e=0;e<t.length;e++){let i=t[e];if(i.startsWith("--")||i.startsWith("-")){let o=i.startsWith("-")&&!i.startsWith("--"),r=o?i.slice(1):i.slice(2),s=o?E[r]:r,c=T[s];if(!c){l(`Unknown option: ${r}`);continue}let f=t[e+1],a=f&&!f.startsWith("-")?f:true;c(a,n),typeof a=="string"&&e++;}else n.entry.push(i);}return n}var g=t=>t instanceof Error?t.message:String(t),B=(t,n)=>{let e=g(t),i="";console.error(`\x1B[31m[ERROR]\x1B[0m ${i}${e}`),process.env.NODE_ENV!=="production"&&t instanceof Error&&t.stack&&console.error("\x1B[2m"+t.stack.split(`
-`).slice(1).join(`
-`)+"\x1B[0m");};var W=[".ts",".js",".mjs",".cjs",".mts",".cts",".json",".jsonc"],j=["bunup.config"];async function b(t){let n=[],e=new Set;async function i(o){if(e.has(o))return;e.add(o);for(let s of j)for(let c of W){let f=`${o}/${s}${c}`;try{if(await Bun.file(f).exists()){let a;if(c===".json"||c===".jsonc"){let p=await Bun.file(f).text();a=JSON.parse(p);}else {let p=await import(f);a=p.default||p,a||(x(`No default export found in ${f}`),a={});}n.unshift({options:{...m,...a},rootDir:o});}}catch(a){l(`Failed to load config from ${f}: ${g(a)}`);}}let r=o.split("/").slice(0,-1).join("/")||"/";r!==o&&await i(r);}return await i(t),n}function y(t,...n){if(!n.length)return t;let e={...t};for(let i of n)if(!(!i||typeof i!="object")){for(let o in i)if(Object.prototype.hasOwnProperty.call(i,o)){let r=e[o],s=i[o];if(s&&typeof s=="object"&&!Array.isArray(s)&&r&&typeof r=="object"&&!Array.isArray(r))e[o]=y(r,s);else if(Array.isArray(s)){let c=Array.isArray(r)?r:[],f=[...c];for(let a of s)c.some(p=>JSON.stringify(p)===JSON.stringify(a))||f.push(a);e[o]=f;}else e[o]=s;}}return e}async function w(t=Bun.argv.slice(2)){let n=h(t),e=await b(process.cwd());if(u(`Running bunup with Bun v${Bun.version}`),e.length===0)await d(y(m,n),process.cwd(),n.watch);else for(let{options:i,rootDir:o}of e){let r=y(m,n,i);console.log(r),await d(r,o,r.watch);}}typeof Bun>"u"&&(console.error(`Bunup requires Bun to run.
-To install Bun, visit https://bun.sh/docs/installation`),process.exit(1));w().catch(t=>{B(t),process.exit(1);});
+'use strict';
+
+var fs = require('fs');
+var path2 = require('path');
+var rollup = require('rollup');
+var dtsPlugin = require('rollup-plugin-dts');
+var ts = require('typescript');
+var chokidar = require('chokidar');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var dtsPlugin__default = /*#__PURE__*/_interopDefault(dtsPlugin);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
+
+// src/errors.ts
+var parseErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var handleError = (error, context) => {
+  const errorMessage = parseErrorMessage(error);
+  const contextPrefix = "";
+  console.error(`\x1B[31m[ERROR]\x1B[0m ${contextPrefix}${errorMessage}`);
+  if (process.env.NODE_ENV !== "production" && error instanceof Error && error.stack) {
+    console.error(
+      "\x1B[2m" + error.stack.split("\n").slice(1).join("\n") + "\x1B[0m"
+    );
+  }
+};
+
+// src/utils.ts
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getDefaultOutputExtension(format, packageType) {
+  switch (format) {
+    case "esm":
+      return ".mjs";
+    case "cjs":
+      return isModulePackage(packageType) ? ".cjs" : ".js";
+    case "iife":
+      return ".global.js";
+  }
+}
+function getDefaultDtsExtention(format, packageType) {
+  switch (format) {
+    case "esm":
+      return ".d.mts";
+    case "cjs":
+      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
+    case "iife":
+      return ".d.ts";
+  }
+}
+function getEntryNamingFormat(extension) {
+  return `[dir]/[name]${extension}`;
+}
+function isModulePackage(packageType) {
+  return packageType === "module";
+}
+function getEntryNameOnly(entry) {
+  return entry.split("/").pop()?.split(".").slice(0, -1).join(".") || "";
+}
+function formatTime(ms) {
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+function getPackageDeps(packageJson) {
+  if (!packageJson) return [];
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      ...Object.keys(packageJson.dependencies || {}),
+      ...Object.keys(packageJson.peerDependencies || {})
+    ])
+  );
+}
+function getResolvedSplitting(splitting, format) {
+  return splitting === void 0 ? format === "esm" : splitting;
+}
+
+// src/helpers/external.ts
+function processPatterns(patterns) {
+  return patterns.map(
+    (pattern) => typeof pattern === "string" ? new RegExp(`^${escapeRegExp(pattern)}($|\\/|\\\\)`) : pattern
+  );
+}
+function getExternalPatterns(options, packageJson) {
+  return processPatterns(options.external || []).concat(
+    getPackageDeps(packageJson).map(
+      (dep) => new RegExp(`^${escapeRegExp(dep)}($|\\/|\\\\)`)
+    )
+  );
+}
+function getNoExternalPatterns(options) {
+  return processPatterns(options.noExternal || []);
+}
+
+// src/logger.ts
+var logger = {
+  MAX_LABEL_LENGTH: 5,
+  colors: {
+    cli: "183",
+    info: "240",
+    warn: "221",
+    error: "203",
+    progress: {
+      ESM: "214",
+      CJS: "114",
+      IIFE: "105",
+      DTS: "75"
+    },
+    default: "255"
+  },
+  labels: {
+    cli: "BUNUP",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR"
+  },
+  formatMessage(colorCode, label, message) {
+    const padding = " ".repeat(
+      Math.max(0, this.MAX_LABEL_LENGTH - label.length)
+    );
+    return `\x1B[38;5;${colorCode}m[${label}]\x1B[0m ${padding}${message}`;
+  },
+  cli(message) {
+    const label = this.labels.cli;
+    console.log(this.formatMessage(this.colors.cli, label, message));
+  },
+  info(message) {
+    const label = this.labels.info;
+    console.log(this.formatMessage(this.colors.info, label, message));
+  },
+  warn(message) {
+    const label = this.labels.warn;
+    console.warn(this.formatMessage(this.colors.warn, label, message));
+  },
+  error(message) {
+    const label = this.labels.error;
+    console.error(this.formatMessage(this.colors.error, label, message));
+  },
+  progress(label, message) {
+    const labelStr = String(label);
+    let colorCode = this.colors.default;
+    for (const [key, value] of Object.entries(this.colors.progress)) {
+      if (labelStr.includes(key)) {
+        colorCode = value;
+        break;
+      }
+    }
+    console.log(this.formatMessage(colorCode, labelStr, message));
+  }
+};
+function getLoggerProgressLabel(label, name) {
+  return `${name ? `${name.replace(/-/g, "_")}_` : ""}${label}`.toUpperCase();
+}
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  entry: [],
+  format: ["esm"],
+  outDir: "dist",
+  minify: false,
+  watch: false,
+  dts: false,
+  target: "node",
+  external: [],
+  clean: true
+};
+function createDefaultBunBuildOptions(options, rootDir) {
+  return {
+    entrypoints: options.entry.map((e) => `${rootDir}/${e}`),
+    outdir: `${rootDir}/${options.outDir}`,
+    minify: createMinifyOptions(options),
+    target: options.target,
+    splitting: options.splitting
+  };
+}
+function createMinifyOptions(options) {
+  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
+  const defaultValue = minify === true;
+  return {
+    whitespace: minifyWhitespace ?? defaultValue,
+    identifiers: minifyIdentifiers ?? defaultValue,
+    syntax: minifySyntax ?? defaultValue
+  };
+}
+
+// src/loaders.ts
+async function loadConfigs(cwd) {
+  const configs = [];
+  for (const ext of [
+    ".ts",
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".jsonc"
+  ]) {
+    const filePath = path2__default.default.join(cwd, `bunup.config${ext}`);
+    try {
+      if (!fs__default.default.existsSync(filePath)) continue;
+      let content;
+      if (ext === ".json" || ext === ".jsonc") {
+        const text = fs__default.default.readFileSync(filePath, "utf8");
+        content = JSON.parse(text);
+      } else {
+        const imported = await import(`file://${filePath}`);
+        content = imported.default || imported;
+        if (!content) {
+          logger.warn(`No default export found in ${filePath}`);
+          content = {};
+        }
+      }
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          configs.push({
+            options: { ...DEFAULT_OPTIONS, ...item },
+            rootDir: cwd
+          });
+        }
+      } else {
+        configs.push({
+          options: { ...DEFAULT_OPTIONS, ...content },
+          rootDir: cwd
+        });
+      }
+      break;
+    } catch (error) {
+      logger.error(
+        `Failed to load config from ${filePath}: ${parseErrorMessage(error)}`
+      );
+    }
+    if (configs.length > 0) break;
+  }
+  return configs;
+}
+function loadPackageJson(cwd) {
+  const packageJsonPath = path2__default.default.join(cwd, "package.json");
+  try {
+    if (!fs__default.default.existsSync(packageJsonPath)) {
+      return null;
+    }
+    const text = fs__default.default.readFileSync(packageJsonPath, "utf8");
+    const content = JSON.parse(text);
+    return content;
+  } catch (error) {
+    logger.error(
+      `Failed to load package.json at ${packageJsonPath}: ${parseErrorMessage(error)}`
+    );
+    return null;
+  }
+}
+function loadTsconfig(tsconfigPath) {
+  if (!fs__default.default.existsSync(tsconfigPath)) {
+    return {};
+  }
+  try {
+    const content = fs__default.default.readFileSync(tsconfigPath, "utf8");
+    const json = JSON.parse(content);
+    return json || {};
+  } catch (error) {
+    logger.warn(
+      `Failed to parse tsconfig at ${tsconfigPath}: ${parseErrorMessage(error)}`
+    );
+    return {};
+  }
+}
+
+// src/dts/index.ts
+async function generateDts(rootDir, entry, format, options, dtsOptions = {}) {
+  const { absoluteRootDir, absoluteEntry } = validateInputs(rootDir, entry);
+  const tsconfigPath = dtsOptions.preferredTsconfigPath ? path2__default.default.resolve(dtsOptions.preferredTsconfigPath) : path2__default.default.join(absoluteRootDir, "tsconfig.json");
+  const tsconfig = await loadTsconfig(tsconfigPath);
+  const compilerOptions = tsconfig.compilerOptions;
+  const packageJson = loadPackageJson(absoluteRootDir);
+  const externalPatterns = getExternalPatterns(options, packageJson);
+  const noExternalPatterns = getNoExternalPatterns(options);
+  let bundle;
+  let result;
+  try {
+    bundle = await rollup.rollup({
+      input: absoluteEntry,
+      onwarn(warning, handler) {
+        if (warning.code === "UNRESOLVED_IMPORT" || warning.code === "CIRCULAR_DEPENDENCY" || warning.code === "EMPTY_BUNDLE") {
+          return;
+        }
+        return handler(warning);
+      },
+      plugins: [
+        dtsPlugin__default.default({
+          tsconfig: tsconfigPath,
+          compilerOptions: {
+            ...compilerOptions ? ts__default.default.parseJsonConfigFileContent(
+              { compilerOptions },
+              ts__default.default.sys,
+              "./"
+            ).options : {},
+            declaration: true,
+            noEmit: false,
+            emitDeclarationOnly: true,
+            noEmitOnError: true,
+            checkJs: false,
+            declarationMap: false,
+            skipLibCheck: true,
+            preserveSymlinks: false,
+            target: ts.ScriptTarget.ESNext
+          }
+        })
+      ],
+      external: (source) => externalPatterns.some((re) => re.test(source)) && !noExternalPatterns.some((re) => re.test(source))
+    });
+    const { output } = await bundle.generate({ format });
+    result = output[0].code;
+  } catch (rollupError) {
+    throw new Error(
+      `Rollup bundling failed: ${parseErrorMessage(rollupError)}`
+    );
+  } finally {
+    if (bundle) await bundle.close();
+  }
+  if (!result) {
+    throw new Error("Failed to generate bundled DTS content");
+  }
+  return result;
+}
+function validateInputs(rootDir, entry) {
+  const absoluteRootDir = path2__default.default.resolve(rootDir);
+  const absoluteEntry = path2__default.default.resolve(absoluteRootDir, entry);
+  if (!fs__default.default.existsSync(absoluteRootDir)) {
+    throw new Error(`Root directory does not exist: ${absoluteRootDir}`);
+  }
+  if (!fs__default.default.existsSync(absoluteEntry)) {
+    throw new Error(`Entry file does not exist: ${absoluteEntry}`);
+  }
+  if (!absoluteEntry.endsWith(".ts")) {
+    throw new Error(
+      `Entry file must be a TypeScript file (.ts): ${absoluteEntry}`
+    );
+  }
+  if (path2__default.default.relative(absoluteRootDir, absoluteEntry).startsWith("..")) {
+    throw new Error(`Entry file must be within rootDir: ${absoluteEntry}`);
+  }
+  return { absoluteRootDir, absoluteEntry };
+}
+
+// src/dts/worker.ts
+self.onmessage = async (event) => {
+  const {
+    name,
+    rootDir,
+    outDir,
+    entry,
+    format,
+    packageType,
+    dtsOptions,
+    options
+  } = event.data;
+  try {
+    const content = await generateDts(
+      rootDir,
+      entry,
+      format,
+      options,
+      dtsOptions
+    );
+    const entryName = getEntryNameOnly(entry);
+    const extension = getDefaultDtsExtention(format, packageType);
+    const outputRelativePath = `${outDir}/${entryName}${extension}`;
+    const outputPath = `${rootDir}/${outputRelativePath}`;
+    await Bun.write(outputPath, content);
+    const response = {
+      name,
+      success: true,
+      outputRelativePath
+    };
+    self.postMessage(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: parseErrorMessage(error)
+    };
+    self.postMessage(response);
+  }
+};
+var DtsWorker = class {
+  constructor(maxWorkers = navigator.hardwareConcurrency || 4) {
+    this.workers = [];
+    this.queue = [];
+    this.busyWorkers = /* @__PURE__ */ new Set();
+    this.isShuttingDown = false;
+    this.maxWorkers = maxWorkers;
+  }
+  async process(task) {
+    if (this.isShuttingDown) {
+      throw new Error("Worker pool is shutting down");
+    }
+    return new Promise((resolve, reject) => {
+      this.queue.push({ task, resolve, reject });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    if (this.queue.length === 0 || this.isShuttingDown) return;
+    if (this.workers.length < this.maxWorkers) {
+      const worker = new Worker(path2__default.default.join(__dirname, "./dtsWorker.js"));
+      this.workers.push(worker);
+      this.assignTaskToWorker(worker);
+    } else {
+      const availableWorker = this.workers.find(
+        (w) => !this.busyWorkers.has(w)
+      );
+      if (availableWorker) {
+        this.assignTaskToWorker(availableWorker);
+      }
+    }
+  }
+  assignTaskToWorker(worker) {
+    const queueItem = this.queue.shift();
+    if (!queueItem) return;
+    const { task, resolve, reject } = queueItem;
+    this.busyWorkers.add(worker);
+    const cleanup = () => {
+      this.busyWorkers.delete(worker);
+      if (this.isShuttingDown && this.busyWorkers.size === 0) {
+        this.terminateAllWorkers();
+      } else {
+        this.processQueue();
+      }
+    };
+    worker.onmessage = (event) => {
+      if (event.data.success) {
+        logger.progress(
+          getLoggerProgressLabel("DTS", event.data.name),
+          event.data.outputRelativePath
+        );
+        resolve();
+      } else {
+        logger.error(`DTS generation failed: ${event.data.error}`);
+        reject(new Error(event.data.error));
+      }
+      cleanup();
+    };
+    worker.onerror = (error) => {
+      const errorMessage = parseErrorMessage(error);
+      logger.error(`Worker error: ${errorMessage}`);
+      reject(error);
+      cleanup();
+    };
+    worker.postMessage(task);
+  }
+  terminateAllWorkers() {
+    this.workers.forEach((worker) => {
+      try {
+        worker.terminate();
+      } catch (error) {
+        logger.error(
+          `Error terminating worker: ${parseErrorMessage(error)}`
+        );
+      }
+    });
+    this.workers = [];
+    this.busyWorkers.clear();
+  }
+  async cleanup() {
+    this.isShuttingDown = true;
+    if (this.busyWorkers.size === 0) {
+      this.terminateAllWorkers();
+      return;
+    }
+    return new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (this.busyWorkers.size === 0) {
+          clearInterval(checkInterval);
+          this.terminateAllWorkers();
+          resolve();
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        this.terminateAllWorkers();
+        resolve();
+      }, 5e3);
+    });
+  }
+};
+
+// src/plugins/external.ts
+function externalPlugin(externalPatterns, noExternalPatterns) {
+  return {
+    name: "bunup:external-plugin",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        const importPath = args.path;
+        const isExternal = externalPatterns.some((re) => re.test(importPath)) && !noExternalPatterns.some((re) => re.test(importPath));
+        if (isExternal) {
+          return { path: importPath, external: true };
+        }
+        return null;
+      });
+    }
+  };
+}
+
+// src/build.ts
+async function build(options, rootDir) {
+  if (!options.entry || options.entry.length === 0 || !options.outDir) {
+    logger.cli(
+      "Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments."
+    );
+    return;
+  }
+  const startTime = performance.now();
+  logger.cli("Build started");
+  const packageJson = loadPackageJson(rootDir);
+  const packageType = packageJson?.type;
+  const externalPatterns = getExternalPatterns(options, packageJson);
+  const noExternalPatterns = getNoExternalPatterns(options);
+  const plugins = [externalPlugin(externalPatterns, noExternalPatterns)];
+  const buildPromises = options.format.flatMap(
+    (fmt) => options.entry.map(
+      (entry) => buildEntry(options, rootDir, entry, fmt, packageType, plugins)
+    )
+  );
+  try {
+    await Promise.all(buildPromises);
+    const buildTimeMs = performance.now() - startTime;
+    const timeDisplay = formatTime(buildTimeMs);
+    logger.cli(`\u26A1 Build success in ${timeDisplay}`);
+  } catch (error) {
+    logger.error("Build process encountered errors.");
+    process.exit(1);
+  }
+  if (options.dts) {
+    const dtsStartTime = performance.now();
+    logger.progress("DTS", "Bundling types");
+    const dtsOptions = typeof options.dts === "object" ? options.dts : {};
+    const entries = dtsOptions.entry || options.entry;
+    const formatsToProcess = options.format.filter((fmt) => {
+      if (fmt === "iife" && !isModulePackage(packageType) && options.format.includes("cjs")) {
+        return false;
+      }
+      return true;
+    });
+    const dtsWorker = new DtsWorker();
+    try {
+      const dtsPromises = formatsToProcess.flatMap(
+        (fmt) => entries.map(
+          (entry) => generateDtsForEntry(
+            options,
+            rootDir,
+            entry,
+            fmt,
+            packageType,
+            dtsOptions,
+            dtsWorker
+          )
+        )
+      );
+      await Promise.all(dtsPromises);
+      const dtsTimeMs = performance.now() - dtsStartTime;
+      const dtsTimeDisplay = formatTime(dtsTimeMs);
+      logger.progress("DTS", `Bundled types in ${dtsTimeDisplay}`);
+    } catch (error) {
+      await dtsWorker.cleanup();
+    }
+    await dtsWorker.cleanup();
+  }
+}
+async function generateDtsForEntry(options, rootDir, entry, fmt, packageType, dtsOptions, dtsWorker) {
+  const task = {
+    name: options.name,
+    rootDir,
+    outDir: options.outDir,
+    entry,
+    format: fmt,
+    packageType,
+    dtsOptions,
+    options
+  };
+  await dtsWorker.process(task);
+}
+async function buildEntry(options, rootDir, entry, fmt, packageType, plugins) {
+  const extension = getDefaultOutputExtension(fmt, packageType);
+  const defaultBunBuildOptions = createDefaultBunBuildOptions(
+    options,
+    rootDir
+  );
+  const result = await Bun.build({
+    ...defaultBunBuildOptions,
+    entrypoints: [`${rootDir}/${entry}`],
+    format: fmt,
+    naming: { entry: getEntryNamingFormat(extension) },
+    splitting: getResolvedSplitting(options.splitting, fmt),
+    plugins
+  });
+  const entryName = getEntryNameOnly(entry);
+  if (!result.success) {
+    result.logs.forEach((log) => {
+      if (log.level === "error") logger.error(log.message);
+      else if (log.level === "warning") logger.warn(log.message);
+      else if (log.level === "info") logger.info(log.message);
+    });
+    throw new Error(`Build failed for ${entry} (${fmt})`);
+  }
+  logger.progress(
+    getLoggerProgressLabel(fmt, options.name),
+    `${options.outDir}/${entryName}${extension}`
+  );
+}
+
+// src/cli-parse.ts
+var cliOptionAliases = {
+  n: "name",
+  f: "format",
+  o: "outDir",
+  m: "minify",
+  w: "watch",
+  d: "dts",
+  e: "external",
+  t: "target",
+  mw: "minifyWhitespace",
+  mi: "minifyIdentifiers",
+  ms: "minifySyntax",
+  c: "clean",
+  s: "splitting",
+  ne: "noExternal"
+};
+var cliOptionHandlers = {
+  name: (value, args) => {
+    args.name = value;
+  },
+  format: (value, args) => {
+    args.format = value.split(",");
+  },
+  outDir: (value, args) => {
+    args.outDir = value;
+  },
+  minify: (value, args) => {
+    args.minify = !!value;
+  },
+  watch: (value, args) => {
+    args.watch = !!value;
+  },
+  dts: (value, args) => {
+    args.dts = !!value;
+  },
+  external: (value, args) => {
+    args.external = value.split(",");
+  },
+  minifyWhitespace: (value, args) => {
+    args.minifyWhitespace = !!value;
+  },
+  minifyIdentifiers: (value, args) => {
+    args.minifyIdentifiers = !!value;
+  },
+  minifySyntax: (value, args) => {
+    args.minifySyntax = !!value;
+  },
+  target: (value, args) => {
+    args.target = value;
+  },
+  clean: (value, args) => {
+    args.clean = !!value;
+  },
+  splitting: (value, args) => {
+    args.splitting = !!value;
+  },
+  noExternal: (value, args) => {
+    args.noExternal = value.split(",");
+  }
+};
+function parseCliOptions(argv) {
+  const cliOptions = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--") || arg.startsWith("-")) {
+      const isShortOption = arg.startsWith("-") && !arg.startsWith("--");
+      const key = isShortOption ? arg.slice(1) : arg.slice(2);
+      const resolvedKey = isShortOption ? cliOptionAliases[key] : key;
+      const handler = cliOptionHandlers[resolvedKey];
+      if (!handler) {
+        logger.error(`Unknown option: ${key}`);
+        continue;
+      }
+      const nextArg = argv[i + 1];
+      const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
+      handler(value, cliOptions);
+      if (typeof value === "string") {
+        i++;
+      }
+    } else {
+      if (!cliOptions.entry) {
+        cliOptions.entry = [];
+      }
+      cliOptions.entry.push(arg);
+    }
+  }
+  return cliOptions;
+}
+
+// src/runtime.ts
+(() => {
+  if (typeof Bun === "undefined") {
+    logger.error(
+      "Bunup requires Bun to run.\nTo install Bun, visit https://bun.sh/docs/installation"
+    );
+    process.exit(1);
+  }
+})();
+async function watch(options, rootDir) {
+  const watchPaths = /* @__PURE__ */ new Set();
+  options.entry.forEach((entry) => {
+    const entryPath = path2__default.default.resolve(rootDir, entry);
+    const parentDir = path2__default.default.dirname(entryPath);
+    watchPaths.add(parentDir);
+  });
+  const watcher = chokidar__default.default.watch(Array.from(watchPaths), {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    },
+    atomic: true,
+    ignorePermissionErrors: true,
+    ignored: [/[\\/]\.git[\\/]/, /[\\/]node_modules[\\/]/, options.outDir]
+  });
+  let debounceTimer = null;
+  let isRebuilding = false;
+  const triggerRebuild = async (changedFile) => {
+    if (isRebuilding) return;
+    isRebuilding = true;
+    try {
+      await build(
+        {
+          ...options,
+          entry: [changedFile],
+          clean: false
+        },
+        rootDir
+      );
+    } catch (error) {
+      logger.error(`Build failed: ${error}`);
+    } finally {
+      isRebuilding = false;
+    }
+  };
+  watcher.on("change", (filePath) => {
+    const changedFile = path2__default.default.relative(rootDir, filePath);
+    logger.cli(`File changed: ${changedFile}`);
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => triggerRebuild(changedFile), 300);
+  });
+  watcher.on("error", (error) => {
+    logger.error(`Watcher error: ${error}`);
+  });
+}
+
+// src/cli.ts
+async function main(args = Bun.argv.slice(2)) {
+  const cliOptions = parseCliOptions(args);
+  const configs = await loadConfigs(process.cwd());
+  const rootDir = process.cwd();
+  if (cliOptions.watch) {
+    logger.cli("Starting watch mode");
+    logger.cli(`Watching for file changes`);
+  }
+  if (configs.length === 0) {
+    const mergedOptions = {
+      ...DEFAULT_OPTIONS,
+      ...cliOptions
+    };
+    if (mergedOptions.clean) cleanOutDir(rootDir, mergedOptions.outDir);
+    await handleBuild(mergedOptions, rootDir);
+  } else {
+    for (const { options, rootDir: rootDir2 } of configs) {
+      if (options.clean) cleanOutDir(rootDir2, options.outDir);
+    }
+    await Promise.all(
+      configs.map(async ({ options, rootDir: rootDir2 }) => {
+        const mergedOptions = {
+          ...DEFAULT_OPTIONS,
+          ...options,
+          ...cliOptions
+        };
+        await handleBuild(mergedOptions, rootDir2);
+      })
+    );
+  }
+  if (!cliOptions.watch) {
+    process.exit(0);
+  }
+}
+async function handleBuild(options, rootDir) {
+  if (options.watch) {
+    await watch(options, rootDir);
+  } else {
+    await build(options, rootDir);
+  }
+}
+function cleanOutDir(rootDir, outdir) {
+  const outdirPath = path2__default.default.join(rootDir, outdir);
+  if (fs__default.default.existsSync(outdirPath)) {
+    try {
+      fs__default.default.rmSync(outdirPath, { recursive: true, force: true });
+    } catch (error) {
+      logger.error(`Failed to clean output directory: ${error}`);
+    }
+  }
+  fs__default.default.mkdirSync(outdirPath, { recursive: true });
+}
+main().catch((error) => {
+  handleError(error);
+  process.exit(1);
+});
+
+exports.main = main;