bunup 0.12.0 → 0.13.4

package/dist/cli/index.js

@@ -2,9 +2,10 @@
 // @bun
 import {
   build,
-  createBuildOptions,
-  processLoadedConfigs
-} from "../shared/bunup-natwy29x.js";
+  printBuildReport,
+  processLoadedConfigs,
+  resolveBuildOptions
+} from "../shared/bunup-sq2zmkp5.js";
 import {
   BunupCLIError,
   BunupWatchError,
@@ -16,22 +17,21 @@ import {
   handleErrorAndExit,
   logTime,
   logger,
-  parseErrorMessage,
-  setSilent
-} from "../shared/bunup-c7jxrymh.js";
+  parseErrorMessage
+} from "../plugins.js";
 
 // packages/bunup/src/cli/index.ts
 import { loadConfig } from "coffi";
 import pc3 from "picocolors";
 // packages/bunup/package.json
-var version = "0.12.0";
+var version = "0.11.30";
 
 // packages/bunup/src/watch.ts
 import path from "path";
 import pc from "picocolors";
-async function watch(partialOptions, rootDir) {
+async function watch(userOptions, rootDir) {
   const watchPaths = new Set;
-  const options = createBuildOptions(partialOptions);
+  const options = resolveBuildOptions(userOptions);
   const uniqueEntries = new Set(options.entry);
   for (const entry of uniqueEntries) {
     const entryPath = path.resolve(rootDir, entry);
@@ -49,21 +49,33 @@ async function watch(partialOptions, rootDir) {
     ]
   });
   let isRebuilding = false;
-  let rebuildCount = 0;
+  let buildCount = 0;
+  let lastChangedFile;
   const triggerRebuild = async (initial, changed) => {
     if (isRebuilding) {
       return;
     }
     isRebuilding = true;
     try {
+      console.clear();
       await new Promise((resolve) => setTimeout(resolve, 20));
+      if (lastChangedFile === changed) {
+        buildCount++;
+      } else {
+        buildCount = 1;
+      }
+      lastChangedFile = changed;
+      if (!initial) {
+        console.log(`
+  ${buildCount > 1 ? pc.magentaBright(`[x${buildCount}] `) : ""}${pc.green(`Changed:`)} ${changed}${options.name ? ` ${pc.bgBlueBright(` ${options.name} `)}` : ""}`);
+      }
       const start = performance.now();
-      await build({ ...options, silent: !initial }, rootDir);
+      const buildOutput = await build(options, rootDir);
+      await printBuildReport(buildOutput, options);
       if (!initial) {
-        console.clear();
-        console.log(`${rebuildCount > 1 ? pc.magenta(`[x${rebuildCount}] `) : ""}${pc.green(`Rebuilt in ${logTime(performance.now() - start)}`)}: ${changed}${options.name ? ` ${pc.bgBlueBright(` ${options.name} `)}` : ""} `);
+        console.log(`
+  ${pc.green("\u2713")} Rebuild completed in ${pc.green(logTime(performance.now() - start))}`);
       }
-      rebuildCount++;
     } catch (error) {
       handleError(error);
     } finally {
@@ -81,396 +93,59 @@ async function watch(partialOptions, rootDir) {
 
 // packages/bunup/src/cli/options.ts
 import pc2 from "picocolors";
-
-// packages/bunup/src/constants/index.ts
-var BUNUP_DOCS_URL = "https://bunup.dev/docs";
-
-// packages/bunup/src/cli/options.ts
-var createHandlers = () => ({
-  boolean: (key) => (value, options) => {
-    options[key] = value === true || value === "true";
-  },
-  string: (key) => (value, options) => {
-    if (typeof value !== "string") {
-      throw new BunupCLIError(`Option --${key} requires a string value`);
-    }
-    options[key] = value;
-  },
-  array: (key) => (value, options) => {
-    if (typeof value !== "string") {
-      throw new BunupCLIError(`Option --${key} requires a string value`);
-    }
-    options[key] = value.split(",");
-  },
-  stringOrBoolean: (key) => (value, options) => {
-    if (typeof value === "boolean") {
-      options[key] = value;
-    } else if (typeof value === "string") {
-      const lowerValue = value.toLowerCase();
-      if (lowerValue === "true" || lowerValue === "false") {
-        options[key] = lowerValue === "true";
-      } else {
-        options[key] = value;
-      }
-    } else {
-      throw new BunupCLIError(`Option --${key} requires a boolean or string value`);
-    }
-  },
-  entry: (value, options) => {
-    if (typeof value !== "string") {
-      throw new BunupCLIError("Entry requires a string value");
-    }
-    const entries = Array.isArray(options.entry) ? [...options.entry] : [];
-    if (entries.includes(value)) {
-      logger.warn(`Duplicate entry '${value}' provided. Skipping.`);
-    } else {
-      entries.push(value);
-    }
-    options.entry = entries;
-  },
-  resolveDts: (value, options) => {
-    if (!options.dts)
-      options.dts = {};
-    if (typeof options.dts === "boolean")
-      options.dts = {};
-    if (typeof value === "string") {
-      if (value === "true" || value === "false") {
-        options.dts.resolve = value === "true";
-      } else {
-        options.dts.resolve = value.split(",");
-      }
-    } else {
-      options.dts.resolve = true;
-    }
-  },
-  showHelp: () => {
-    displayHelp();
-    process.exit(0);
-  },
-  showVersion: () => {
-    console.log(version);
-    process.exit(0);
-  }
-});
-var handlers = createHandlers();
-var OPTION_DEFINITIONS = {
-  name: {
-    flags: ["n", "name"],
-    handler: handlers.string("name"),
-    description: "Name of the build configuration for logging and identification",
-    type: "string",
-    category: "utility"
-  },
-  format: {
-    flags: ["f", "format"],
-    handler: handlers.array("format"),
-    description: "Output formats for the bundle (esm, cjs, iife)",
-    type: "array",
-    default: "cjs",
-    category: "build"
-  },
-  outDir: {
-    flags: ["o", "out-dir"],
-    handler: handlers.string("outDir"),
-    description: "Output directory for the bundled files",
-    type: "string",
-    default: "dist",
-    category: "output"
-  },
-  minify: {
-    flags: ["m", "minify"],
-    handler: handlers.boolean("minify"),
-    description: "Enable all minification options",
-    type: "boolean",
-    category: "minification"
-  },
-  watch: {
-    flags: ["w", "watch"],
-    handler: handlers.boolean("watch"),
-    description: "Watch for file changes and rebuild automatically",
-    type: "boolean",
-    category: "development"
-  },
-  dts: {
-    flags: ["d", "dts"],
-    handler: handlers.boolean("dts"),
-    description: "Generate TypeScript declaration files (.d.ts)",
-    type: "boolean",
-    category: "development"
-  },
-  banner: {
-    flags: ["bn", "banner"],
-    handler: handlers.string("banner"),
-    description: "A banner to be added to the final bundle",
-    type: "string",
-    category: "output"
-  },
-  footer: {
-    flags: ["ft", "footer"],
-    handler: handlers.string("footer"),
-    description: "A footer to be added to the final bundle",
-    type: "string",
-    category: "output"
-  },
-  external: {
-    flags: ["e", "external"],
-    handler: handlers.array("external"),
-    description: "External packages that should not be bundled",
-    type: "array",
-    category: "build"
-  },
-  sourcemap: {
-    flags: ["sm", "sourcemap"],
-    handler: handlers.stringOrBoolean("sourcemap"),
-    description: "Type of sourcemap to generate (none, linked, external, inline)",
-    type: "string|boolean",
-    default: "none",
-    category: "output"
-  },
-  target: {
-    flags: ["t", "target"],
-    handler: handlers.string("target"),
-    description: "The target environment for the bundle",
-    type: "string",
-    default: "node",
-    category: "build"
-  },
-  minifyWhitespace: {
-    flags: ["mw", "minify-whitespace"],
-    handler: handlers.boolean("minifyWhitespace"),
-    description: "Minify whitespace in the output",
-    type: "boolean",
-    category: "minification"
-  },
-  minifyIdentifiers: {
-    flags: ["mi", "minify-identifiers"],
-    handler: handlers.boolean("minifyIdentifiers"),
-    description: "Minify identifiers in the output",
-    type: "boolean",
-    category: "minification"
-  },
-  minifySyntax: {
-    flags: ["ms", "minify-syntax"],
-    handler: handlers.boolean("minifySyntax"),
-    description: "Minify syntax in the output",
-    type: "boolean",
-    category: "minification"
-  },
-  clean: {
-    flags: ["c", "clean"],
-    handler: handlers.boolean("clean"),
-    description: "Clean the output directory before building",
-    type: "boolean",
-    default: "true",
-    category: "output"
-  },
-  splitting: {
-    flags: ["s", "splitting"],
-    handler: handlers.boolean("splitting"),
-    description: "Enable code splitting",
-    type: "boolean",
-    category: "build"
-  },
-  noExternal: {
-    flags: ["ne", "no-external"],
-    handler: handlers.array("noExternal"),
-    description: "Packages that should be bundled even if they are in external",
-    type: "array",
-    category: "build"
-  },
-  preferredTsconfigPath: {
-    flags: ["preferred-tsconfig-path"],
-    handler: handlers.string("preferredTsconfigPath"),
-    description: "Path to a preferred tsconfig.json file for declaration generation",
-    type: "string",
-    category: "development"
-  },
-  silent: {
-    flags: ["silent"],
-    handler: handlers.boolean("silent"),
-    description: "Disable logging during the build process",
-    type: "boolean",
-    default: "false",
-    category: "utility"
-  },
-  config: {
-    flags: ["config"],
-    handler: handlers.string("config"),
-    description: "Path to a specific configuration file to use",
-    type: "string",
-    category: "utility"
-  },
-  publicPath: {
-    flags: ["pp", "public-path"],
-    handler: handlers.string("publicPath"),
-    description: "Prefix to be added to specific import paths in bundled code",
-    type: "string",
-    category: "output"
-  },
-  env: {
-    flags: ["env"],
-    handler: handlers.string("env"),
-    description: "Controls how environment variables are handled during bundling",
-    type: "string",
-    category: "build"
-  },
-  filter: {
-    flags: ["filter"],
-    handler: handlers.array("filter"),
-    description: "Filter specific packages to build in a workspace",
-    type: "array",
-    category: "workspace"
-  },
-  new: {
-    flags: ["new"],
-    handler: handlers.boolean("new"),
-    description: "Create a new project with bunup",
-    type: "boolean",
-    category: "utility"
-  },
-  init: {
-    flags: ["init"],
-    handler: handlers.boolean("init"),
-    description: "Initialize bunup in an existing project",
-    type: "boolean",
-    category: "utility"
-  },
-  entry: {
-    flags: ["entry"],
-    handler: handlers.entry,
-    description: "Entry point files for the build",
-    type: "string",
-    category: "build"
-  },
-  resolveDts: {
-    flags: ["rd", "resolve-dts"],
-    handler: handlers.resolveDts,
-    description: "Configure DTS resolution options",
-    type: "string|boolean",
-    category: "development"
-  },
-  onSuccess: {
-    flags: ["onSuccess"],
-    handler: handlers.string("onSuccess"),
-    description: "Command to run after the build process completes",
-    type: "string",
-    category: "utility"
-  },
-  help: {
-    flags: ["h", "help"],
-    handler: handlers.showHelp,
-    description: "Show this help message",
-    type: "boolean",
-    category: "utility"
-  },
-  version: {
-    flags: ["v", "version"],
-    handler: handlers.showVersion,
-    description: "Show version number",
-    type: "boolean",
-    category: "utility"
-  }
-};
-var createFlagLookupMap = () => {
-  const lookup = {};
-  for (const definition of Object.values(OPTION_DEFINITIONS)) {
-    for (const flag of definition.flags) {
-      lookup[flag] = definition.handler;
-    }
-  }
-  return lookup;
-};
-var flagToHandler = createFlagLookupMap();
-var displayHelp = () => {
-  const categoryLabels = {
-    build: "Build Options",
-    output: "Output Options",
-    development: "Development Options",
-    minification: "Minification Options",
-    workspace: "Workspace Options",
-    utility: "Utility Options"
-  };
-  console.log();
-  console.log(pc2.cyan(pc2.bold("bunup")));
-  console.log();
-  console.log("\u26A1\uFE0F A blazing-fast build tool for your libraries built with Bun");
-  console.log();
-  console.log(pc2.cyan("Usage:"));
-  console.log("  bunup [entry...] [options]");
-  console.log("  bunup --init");
-  console.log("  bunup --new");
-  console.log();
-  for (const [categoryKey, categoryName] of Object.entries(categoryLabels)) {
-    const categoryOptions = Object.values(OPTION_DEFINITIONS).filter((option) => option.category === categoryKey);
-    if (categoryOptions.length === 0)
-      return;
-    console.log(pc2.cyan(`${categoryName}:`));
-    for (const option of categoryOptions) {
-      const flags = option.flags.map((flag) => flag.length === 1 ? `-${flag}` : `--${flag}`).join(", ");
-      const flagsDisplay = pc2.green(flags);
-      const typeDisplay = pc2.dim(`<${option.type}>`);
-      const defaultDisplay = option.default ? pc2.yellow(`(default: ${option.default})`) : "";
-      console.log(`  ${flagsDisplay} ${typeDisplay}`);
-      console.log(`    ${pc2.dim(option.description)} ${defaultDisplay}`);
-      console.log();
-    }
-  }
-  console.log(pc2.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(pc2.dim("For more information:"));
-  console.log(`  ${pc2.cyan(pc2.underline(BUNUP_DOCS_URL))}`);
-  console.log();
-};
-var parseArgument = (arg, nextArg) => {
-  if (arg.startsWith("--")) {
-    if (arg.includes("=")) {
-      const [key, value] = arg.slice(2).split("=", 2);
-      return { key, value, skipNext: false };
-    } else {
-      const key = arg.slice(2);
-      const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
-      return { key, value, skipNext: typeof value === "string" };
-    }
-  } else if (arg.startsWith("-")) {
-    const key = arg.slice(1);
-    const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
-    return { key, value, skipNext: typeof value === "string" };
-  }
-  return null;
-};
+import { cli, z } from "zlye";
+var program = cli().name("bunup").version(version).description("A blazing-fast build tool for your TypeScript/React libraries \u2014 built on Bun").with({
+  ignoreOptionDefaultValue: true
+}).example([
+  pc2.gray(`${pc2.blue("bunup src/index.ts")}                            # Basic build`),
+  pc2.gray(`${pc2.blue("bunup src/**/*.ts")}                             # Glob pattern for multiple files`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts --watch")}                    # Watch mode`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts --format cjs,esm")}           # Multiple formats`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts --target bun")}               # Bun target`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts src/cli.ts")}                 # Multiple entries`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts --dts.splitting")}            # Declaration splitting`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts --no-clean")}                 # Disable cleaning output directory before build`)
+]).option("entry", z.union(z.string().describe("Entry file or glob pattern"), z.array(z.string()).describe("Multiple entry files or globs")).alias("e").optional()).option("config", z.string().describe("Path to configuration file").alias("c").example("./configs/custom.bunup.config.js").optional()).option("filter", z.array(z.string()).describe("Filter workspace packages by name").optional()).option("name", z.string().describe("Name of the build configuration (for logging and identification)").example("my-library").optional()).option("out-dir", z.string().describe("Output directory for bundled files").alias("o").default("dist")).option("format", z.union(z.string().choices(["esm", "cjs", "iife"]).describe("Single output format"), z.array(z.string().choices(["esm", "cjs", "iife"])).describe("Multiple output formats")).alias("f").default("esm")).option("minify", z.boolean().describe("Enable all minification options (whitespace, identifiers, syntax)").optional()).option("minify-whitespace", z.boolean().describe("Minify whitespace in the output to reduce file size").optional()).option("minify-identifiers", z.boolean().describe("Minify identifiers by renaming variables to shorter names").optional()).option("minify-syntax", z.boolean().describe("Minify syntax by optimizing code structure").optional()).option("watch", z.boolean().describe("Watch for file changes and rebuild automatically").optional()).option("clean", z.boolean().describe("Clean the output directory before building").default(true)).option("silent", z.boolean().describe("Disable logging during the build process").alias("q").optional()).option("splitting", z.boolean().describe("Enable code splitting").default(true, "enabled by default for ESM format")).option("conditions", z.array(z.string()).describe("Package.json export conditions for import resolution").optional()).option("target", z.string().choices(["bun", "node", "browser"]).describe("Target environment for the bundle").alias("t").default("node")).option("external", z.array(z.string()).describe("External packages that should not be bundled").optional()).option("no-external", z.array(z.string()).describe("Packages that should be bundled even if listed in external").optional()).option("shims", z.boolean().describe("Enable shims for Node.js globals and ESM/CJS interoperability").optional()).option("report", z.object({
+  gzip: z.boolean().describe("Enable gzip compression size calculation").default(true),
+  brotli: z.boolean().describe("Enable brotli compression size calculation").optional(),
+  "max-bundle-size": z.number().describe("Maximum bundle size in bytes. Will warn if exceeded").optional()
+}).describe("Configuration for the build report").optional()).option("dts", z.union(z.boolean().describe("Generate TypeScript declaration files (.d.ts)"), z.object({
+  entry: z.union(z.string().describe("Single entrypoint for declaration file generation"), z.array(z.string()).describe("Multiple entrypoints for declaration file generation")).optional(),
+  resolve: z.union(z.boolean().describe("Resolve types from dependencies"), z.array(z.string()).describe("Names or patterns of packages from which to resolve types")).optional(),
+  splitting: z.boolean().describe("Enable declaration file splitting").optional(),
+  minify: z.boolean().describe("Minify generated declaration files").optional()
+})).default(true)).option("preferred-tsconfig-path", z.string().describe("Path to preferred tsconfig.json for declaration generation").example("./tsconfig.build.json").optional()).option("sourcemap", z.union(z.boolean().describe("Generate a sourcemap (uses the inline type by default)"), z.string().choices(["none", "linked", "inline", "external"]).describe("Generate a sourcemap with a specific type")).optional()).option("define", z.object(z.string()).describe("Define global constants replaced at build time").example(`--define.PACKAGE_VERSION='"1.0.0"'`).optional()).option("env", z.union(z.string().choices(["inline", "disable"]).describe("inline: inject all, disable: inject none"), z.string().regex(/\*$/, "Environment prefix must end with *").describe("Inject env vars with this prefix").example("MYAPP_*").transform((val) => val), z.object(z.string()).describe("Explicit env var mapping").example('--env.NODE_ENV="production" --env.API_URL="https://api.example.com"')).optional()).option("banner", z.string().describe("Banner text added to the top of bundle files").optional()).option("footer", z.string().describe("Footer text added to the bottom of bundle files").optional()).option("drop", z.array(z.string()).describe("Remove function calls from bundle").example("--drop console,debugger").optional()).option("loader", z.object(z.string().choices([
+  "js",
+  "jsx",
+  "ts",
+  "tsx",
+  "json",
+  "toml",
+  "file",
+  "napi",
+  "wasm",
+  "text",
+  "css",
+  "html"
+])).describe("File extension to loader mapping").example("--loader.'.css'=text --loader.'.txt'=file").optional()).option("public-path", z.string().describe("Public path prefix for assets and chunk files").example("https://cdn.example.com/").optional()).option("ignore-dce-annotations", z.boolean().describe("Ignore dead code elimination annotations (@__PURE__, sideEffects)")).option("emit-dce-annotations", z.boolean().describe("Force emit @__PURE__ annotations even with minification")).option("on-success", z.string().describe("Command to run after successful build").optional()).option("css", z.object({
+  "typed-modules": z.boolean().describe("Generate TypeScript definitions for CSS modules").default(true)
+}).optional()).rest("entries", z.string().describe("Entry point files to bundle"));
 var parseCliOptions = (argv) => {
-  const options = {};
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
-    const nextArg = argv[i + 1];
-    if (arg.startsWith("-")) {
-      const parsed = parseArgument(arg, nextArg);
-      if (!parsed) {
-        throw new BunupCLIError(`Invalid argument: ${arg}`);
-      }
-      const { key, value, skipNext } = parsed;
-      const handler = flagToHandler[key];
-      if (!handler) {
-        throw new BunupCLIError(`Unknown option: ${arg}`);
-      }
-      handler(value, options);
-      if (skipNext) {
-        i++;
-      }
-    } else {
-      OPTION_DEFINITIONS.entry.handler(arg, options);
-    }
+  const result = program.parse(argv);
+  if (!result) {
+    throw new BunupCLIError("Failed to parse CLI options");
   }
-  return options;
+  const { options, rest } = result;
+  const parsedOptions = {
+    ...options,
+    ...rest.length > 0 ? { entry: rest } : {}
+  };
+  return parsedOptions;
 };
 
 // packages/bunup/src/cli/index.ts
 async function main(args = Bun.argv.slice(2)) {
   const cliOptions = parseCliOptions(args);
-  setSilent(cliOptions.silent);
   const cwd = process.cwd();
   const { config, filepath } = await loadConfig({
     name: "bunup.config",
@@ -480,6 +155,10 @@ async function main(args = Bun.argv.slice(2)) {
     packageJsonProperty: "bunup"
   });
   const configsToProcess = !config ? [{ rootDir: cwd, options: cliOptions }] : await processLoadedConfigs(config, cwd, cliOptions.filter);
+  const shouldSilent = cliOptions.watch || cliOptions.silent || configsToProcess.some((c) => ensureArray(c.options).some((o) => o.silent));
+  if (shouldSilent) {
+    logger.setSilent(true);
+  }
   logger.info(`Using bunup v${version} and bun v${Bun.version}`, {
     muted: true
   });
@@ -488,36 +167,40 @@ async function main(args = Bun.argv.slice(2)) {
       muted: true
     });
   }
-  const startTime = performance.now();
   logger.info("Build started");
+  const startTime = performance.now();
   await Promise.all(configsToProcess.flatMap(({ options, rootDir }) => {
     const optionsArray = ensureArray(options);
     return optionsArray.map(async (o) => {
-      const partialOptions = {
+      const userOptions = {
         ...o,
         ...removeCliOnlyOptions(cliOptions)
       };
-      if (partialOptions.watch) {
-        await watch(partialOptions, rootDir);
+      if (userOptions.watch) {
+        await watch(userOptions, rootDir);
       } else {
-        await build(partialOptions, rootDir);
+        await build(userOptions, rootDir);
       }
     });
   }));
-  const buildTimeMs = performance.now() - startTime;
-  logger.success(`Build completed in ${pc3.green(logTime(buildTimeMs))}`);
   if (cliOptions.watch) {
-    logger.info(pc3.dim("Watching for file changes..."));
+    console.log(`
+  ${pc3.bgMagentaBright(" WATCH ")} Watching for file changes...
+`);
   }
+  const buildTimeMs = performance.now() - startTime;
+  logger.space();
+  logger.success(`Build completed in ${pc3.green(logTime(buildTimeMs))}`);
   if (!cliOptions.watch) {
     process.exit(process.exitCode ?? 0);
   }
 }
+var CLI_ONLY_OPTIONS = ["config", "filter"];
 function removeCliOnlyOptions(options) {
-  return {
-    ...options,
-    config: undefined,
-    filter: undefined
-  };
+  const cleanedOptions = { ...options };
+  for (const option of CLI_ONLY_OPTIONS) {
+    delete cleanedOptions[option];
+  }
+  return cleanedOptions;
 }
 main().catch((error) => handleErrorAndExit(error));

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-5f54ngsb";
-declare function build(partialOptions: Partial<BuildOptions>, rootDir?: string): Promise<void>;
+import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-s6gfzz2v";
+declare function build(userOptions: Partial<BuildOptions>, rootDir?: string): Promise<BuildOutput>;
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: WithOptional<DefineWorkspaceItem, "config">[], sharedOptions?: Partial<DefineConfigItem>): DefineWorkspaceItem[];
 export { defineWorkspace, defineConfig, build, DefineWorkspaceItem, DefineConfigItem, BunupPlugin, BuildOutputFile, BuildOutput, BuildOptions, BuildMeta, BuildContext };

package/dist/index.js

@@ -1,8 +1,8 @@
 // @bun
 import {
   build
-} from "./shared/bunup-natwy29x.js";
-import"./shared/bunup-c7jxrymh.js";
+} from "./shared/bunup-sq2zmkp5.js";
+import"./plugins.js";
 // packages/bunup/src/define.ts
 function defineConfig(options) {
   return options;