bunup 0.8.57 → 0.8.58

package/README.md

@@ -12,7 +12,7 @@
 
 [![NPM Downloads](https://img.shields.io/npm/dm/bunup?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAtOTYwIDk2MCA5NjAiIHdpZHRoPSIyNHB4IiBmaWxsPSIjMDAwMDAwIj48cGF0aCBkPSJNNDgwLTMyMCAyODAtNTIwbDU2LTU4IDEwNCAxMDR2LTMyNmg4MHYzMjZsMTA0LTEwNCA1NiA1OC0yMDAgMjAwWk0xNjAtMTYwdi0yMDBoODB2MTIwaDQ4MHYtMTIwaDgwdjIwMEgxNjBaIi8%2BPC9zdmc%2B&labelColor=ffc44e&color=212121)](https://www.npmjs.com/package/bunup) [![NPM Version](https://img.shields.io/npm/v/bunup?logo=npm&logoColor=212121&label=version&labelColor=ffc44e&color=212121)](https://npmjs.com/package/bunup) [![Built with Bun](https://img.shields.io/badge/Built_with-Bun-fbf0df?logo=bun&labelColor=212121)](https://bun.sh) [![sponsor](https://img.shields.io/badge/sponsor-EA4AAA?logo=githubsponsors&labelColor=FAFAFA)](https://github.com/sponsors/arshad-yaseen)
 
-Bunup is the **blazing-fast build tool** for TypeScript and JavaScript libraries, designed for flawless developer experience and speed, **powered by Bun**. 
+Bunup is the **blazing-fast build tool** for TypeScript libraries, designed for flawless developer experience and speed, **powered by Bun**. 
 
 ![Bunup benchmarks](/assets/benchmarks.png)
 

package/dist/{chunk-0e6rexd1.js → chunk-0j56xynx.js}

@@ -1,6 +1,6 @@
 import {
   BunupPluginError
-} from "./chunk-w9q3brxd.js";
+} from "./chunk-2g0gpaee.js";
 
 // src/plugins/utils.ts
 import pc from "picocolors";

package/dist/{chunk-w9q3brxd.js → chunk-2g0gpaee.js}

@@ -458,5 +458,10 @@ async function getFilesFromGlobs(patterns, cwd) {
   }
   return Array.from(includedFiles);
 }
+function isTypeScriptFile(path2) {
+  if (!path2)
+    return false;
+  return TS_RE.test(path2);
+}
 
-export { __toESM, __require, setSilent, logTable, link, logger, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage, handleError, handleErrorAndExit, JS_TS_RE, JS_DTS_RE, CSS_RE, ensureArray, getDefaultOutputExtension, getDefaultDtsExtention, formatTime, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, isDirectoryPath, pathExistsSync, formatListWithAnd, getFilesFromGlobs };
+export { __toESM, __require, setSilent, logTable, link, logger, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage, handleError, handleErrorAndExit, JS_TS_RE, JS_DTS_RE, CSS_RE, ensureArray, getDefaultOutputExtension, getDefaultDtsExtention, formatTime, getPackageDeps, formatFileSize, getShortFilePath, cleanOutDir, cleanPath, isDirectoryPath, pathExistsSync, formatListWithAnd, getFilesFromGlobs, isTypeScriptFile };

package/dist/{chunk-whm2fp6r.js → chunk-8dk0fkzd.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-gh7z7s46.js";
 import {
   displayBunupGradientArt
-} from "./chunk-gyyqw66f.js";
+} from "./chunk-qteft286.js";
 import {
   formatListWithAnd,
   link
-} from "./chunk-w9q3brxd.js";
+} from "./chunk-2g0gpaee.js";
 
 // src/cli/init.ts
 import fs from "fs";
@@ -65,10 +65,9 @@ async function initializeWorkspace(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);
+  await generateConfiguration(configMethod, entryFiles, outputFormats, packageJsonPath);
+  await handleBuildScripts(packageJsonPath, entryFiles, outputFormats, configMethod);
 }
 async function collectWorkspacePackages() {
   const packages = [];
@@ -98,13 +97,11 @@ async function collectWorkspacePackages() {
     });
     const entryFiles = await collectEntryFilesForPackage(packageRoot, packageName);
     const outputFormats = await selectOutputFormats();
-    const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
     packages.push({
       name: packageName,
       root: packageRoot,
       entryFiles,
-      outputFormats,
-      shouldGenerateDts
+      outputFormats
     });
     const shouldAddMore = await confirm({
       message: "Do you want to add another package?",
@@ -183,15 +180,6 @@ async function selectOutputFormats() {
     initialValues: ["esm", "cjs"]
   });
 }
-async function promptForTypeScriptDeclarations(entryFiles) {
-  const hasTypeScriptFiles = entryFiles.some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
-  if (!hasTypeScriptFiles)
-    return false;
-  return await confirm({
-    message: "Generate TypeScript declarations?",
-    initialValue: true
-  });
-}
 async function selectWorkspaceConfigurationMethod() {
   return await select({
     message: "How would you like to configure your workspace?",
@@ -222,18 +210,18 @@ async function generateWorkspaceConfiguration(configMethod, workspacePackages) {
   const configContent = createWorkspaceConfigFileContent(workspacePackages);
   await Bun.write(`bunup.config.${configMethod}`, configContent);
 }
-async function generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath) {
+async function generateConfiguration(configMethod, entryFiles, outputFormats, 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));
+    await Bun.write(`bunup.config.${configMethod}`, createConfigFileContent(entryFiles, outputFormats));
   } else if (configMethod === "json") {
     const { data: packageJsonConfig } = await loadPackageJson();
     const updatedConfig = {
       ...packageJsonConfig,
-      bunup: createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts)
+      bunup: createPackageJsonConfig(entryFiles, outputFormats)
     };
     await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
   }
@@ -259,10 +247,10 @@ async function handleWorkspaceBuildScripts(packageJsonPath) {
   };
   await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
 }
-async function handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod) {
+async function handleBuildScripts(packageJsonPath, entryFiles, outputFormats, configMethod) {
   const { data: packageJsonConfig } = await loadPackageJson();
   const existingScripts = packageJsonConfig?.scripts ?? {};
-  const newScripts = createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod);
+  const newScripts = createBuildScripts(entryFiles, outputFormats, configMethod);
   const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
   if (conflictingScripts.length > 0) {
     const shouldOverride = await confirm({
@@ -287,8 +275,7 @@ function createWorkspaceConfigFileContent(workspacePackages) {
     root: '${pkg.root}',
     config: {
       entry: [${pkg.entryFiles.map((file) => `'${file}'`).join(", ")}],
-      format: [${pkg.outputFormats.map((format) => `'${format}'`).join(", ")}],${pkg.shouldGenerateDts ? `
-      dts: true,` : ""}
+      format: [${pkg.outputFormats.map((format) => `'${format}'`).join(", ")}],
     },
   }`;
   }).join(`,
@@ -300,21 +287,19 @@ ${packagesConfig}
 ])
 `;
 }
-function createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts) {
+function createConfigFileContent(entryFiles, outputFormats) {
   return `import { defineConfig } from 'bunup'
 
 export default defineConfig({
 	entry: [${entryFiles.map((file) => `'${file}'`).join(", ")}],
-	format: [${outputFormats.map((format) => `'${format}'`).join(", ")}],${shouldGenerateDts ? `
-	dts: true,` : ""}
+	format: [${outputFormats.map((format) => `'${format}'`).join(", ")}],
 })
 `;
 }
-function createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts) {
+function createPackageJsonConfig(entryFiles, outputFormats) {
   return {
     entry: entryFiles,
-    format: outputFormats,
-    ...shouldGenerateDts && { dts: true }
+    format: outputFormats
   };
 }
 function createWorkspaceBuildScripts() {
@@ -323,8 +308,8 @@ function createWorkspaceBuildScripts() {
     dev: "bunup --watch"
   };
 }
-function createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod) {
-  const cliOptions = configMethod === "none" ? ` ${entryFiles.join(" ")} --format ${outputFormats.join(",")}${shouldGenerateDts ? " --dts" : ""}` : "";
+function createBuildScripts(entryFiles, outputFormats, configMethod) {
+  const cliOptions = configMethod === "none" ? ` ${entryFiles.join(" ")} --format ${outputFormats.join(",")}` : "";
   return {
     build: `bunup${cliOptions}`,
     dev: `bunup${cliOptions} --watch`

package/dist/{chunk-31j04536.js → chunk-kspt827v.js}

@@ -1,11 +1,11 @@
 // @bun
 import {
   displayBunupGradientArt
-} from "./chunk-gyyqw66f.js";
+} from "./chunk-qteft286.js";
 import {
   link,
   pathExistsSync
-} from "./chunk-w9q3brxd.js";
+} from "./chunk-2g0gpaee.js";
 
 // src/cli/new.ts
 import { renameSync } from "fs";

package/dist/{chunk-gyyqw66f.js → chunk-qteft286.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-w9q3brxd.js";
+} from "./chunk-2g0gpaee.js";
 
 // src/cli/utils.ts
 import pc from "picocolors";

package/dist/{chunk-2hchnc6a.js → chunk-wav05ehp.js}

@@ -3,7 +3,7 @@ import {
   filterBunupPlugins,
   runPluginBuildDoneHooks,
   runPluginBuildStartHooks
-} from "./chunk-0e6rexd1.js";
+} from "./chunk-0j56xynx.js";
 import {
   loadPackageJson
 } from "./chunk-gh7z7s46.js";
@@ -19,12 +19,13 @@ import {
   getFilesFromGlobs,
   getPackageDeps,
   getShortFilePath,
+  isTypeScriptFile,
   link,
   logTable,
   logger,
   parseErrorMessage,
   setSilent
-} from "./chunk-w9q3brxd.js";
+} from "./chunk-2g0gpaee.js";
 
 // src/build.ts
 import path from "path";
@@ -145,7 +146,7 @@ ${text}`;
 // src/options.ts
 var DEFAULT_OPTIONS = {
   entry: ["src/index.ts"],
-  format: ["cjs"],
+  format: ["esm", "cjs"],
   outDir: "dist",
   target: "node",
   clean: true
@@ -325,7 +326,7 @@ async function build(partialOptions, rootDir = process.cwd()) {
     }
   });
   await Promise.all(buildPromises);
-  if (options.dts) {
+  if (options.dts ?? entrypoints.some(isTypeScriptFile)) {
     try {
       const { entry, splitting, ...dtsOptions } = typeof options.dts === "object" ? options.dts : {};
       const dtsResult = await generateDts(ensureArray(entry ?? entrypoints), {

package/dist/cli/index.js

@@ -3,8 +3,8 @@
 import {
   build,
   createBuildOptions
-} from "../chunk-2hchnc6a.js";
-import"../chunk-0e6rexd1.js";
+} from "../chunk-wav05ehp.js";
+import"../chunk-0j56xynx.js";
 import {
   processLoadedConfigs
 } from "../chunk-gh7z7s46.js";
@@ -21,14 +21,14 @@ import {
   logger,
   parseErrorMessage,
   setSilent
-} from "../chunk-w9q3brxd.js";
+} from "../chunk-2g0gpaee.js";
 
 // src/cli/index.ts
 import { loadConfig } from "coffi";
 import pc3 from "picocolors";
 import { exec } from "tinyexec";
 // package.json
-var version = "0.8.57";
+var version = "0.8.58";
 
 // src/watch.ts
 import path from "path";
@@ -482,12 +482,12 @@ var parseCliOptions = (argv) => {
 async function main(args = Bun.argv.slice(2)) {
   const cliOptions = parseCliOptions(args);
   if (cliOptions.new) {
-    const { newProject } = await import("../chunk-31j04536.js");
+    const { newProject } = await import("../chunk-kspt827v.js");
     await newProject();
     return;
   }
   if (cliOptions.init) {
-    const { init } = await import("../chunk-whm2fp6r.js");
+    const { init } = await import("../chunk-8dk0fkzd.js");
     await init();
     return;
   }

package/dist/index.d.ts

@@ -1,4 +1,355 @@
-import { Arrayable, BuildOptions, DefineConfigItem, DefineWorkspaceItem, Plugin } from "./chunk-w6swmckt";
+import { GenerateDtsOptions } from "typeroll";
+import { BunPlugin } from "bun";
+type MaybePromise<T> = Promise<T> | T;
+type WithOptional<
+	T,
+	K extends keyof T
+> = Omit<T, K> & Partial<Pick<T, K>>;
+type Arrayable<T> = T | T[];
+type DefineConfigItem = Omit<WithOptional<BuildOptions, "outDir" | "format">, "watch">;
+type DefineWorkspaceItem = {
+	name: string
+	root: string
+	config: DefineConfigItem | DefineConfigItem[]
+};
+type PackageJson = {
+	/** The parsed content of the package.json file */
+	data: Record<string, any> | null
+	/** The path to the package.json file */
+	path: string | null
+};
+/**
+* Represents a Bun plugin that can be used with Bunup
+*/
+type BunupBunPlugin = {
+	/** Identifies this as a native Bun plugin */
+	type: "bun"
+	/** Optional name for the plugin */
+	name?: string
+	/** The actual Bun plugin implementation */
+	plugin: BunPlugin
+};
+/**
+* Represents the meta data of the build
+*/
+type BuildMeta = {
+	/** The package.json file */
+	packageJson: PackageJson
+	/** The root directory of the build */
+	rootDir: string
+};
+type BuildOutputFile = {
+	/**
+	* The entry point for which this file was generated
+	*
+	* Undefined for non-entry point files (e.g., assets, sourcemaps, chunks)
+	*/
+	entrypoint: string | undefined
+	/** The kind of the file */
+	kind: "entry-point" | "chunk" | "asset" | "sourcemap" | "bytecode"
+	/** Path to the generated file */
+	fullPath: string
+	/** Path to the generated file relative to the root directory */
+	relativePathToRootDir: string
+	/** Path to the generated file relative to the output directory */
+	relativePathToOutputDir: string
+	/** Whether the file is a dts file */
+	dts: boolean
+	/** The format of the output file */
+	format: Format
+};
+/**
+* Represents the output of a build operation
+*/
+type BuildOutput = {
+	/** Array of generated files with their paths and contents */
+	files: BuildOutputFile[]
+};
+/**
+* Context provided to build hooks
+*/
+type BuildContext = {
+	/** The build options that were used */
+	options: BuildOptions
+	/** The output of the build */
+	output: BuildOutput
+	/** The meta data of the build */
+	meta: BuildMeta
+};
+/**
+* Hooks that can be implemented by Bunup plugins
+*/
+type BunupPluginHooks = {
+	/**
+	* Called when a build is successfully completed
+	* @param ctx Build context containing options and output
+	*/
+	onBuildDone?: (ctx: BuildContext) => MaybePromise<void>
+	/**
+	* Called before a build starts
+	* @param options Build options that will be used
+	*/
+	onBuildStart?: (options: BuildOptions) => MaybePromise<void>
+};
+/**
+* Represents a Bunup-specific plugin
+*/
+type BunupPlugin = {
+	/** Identifies this as a Bunup-specific plugin */
+	type: "bunup"
+	/** Optional name for the plugin */
+	name?: string
+	/** The hooks implemented by this plugin */
+	hooks: BunupPluginHooks
+};
+/**
+* Union type representing all supported plugin types
+*/
+type Plugin = BunupBunPlugin | BunupPlugin;
+type Loader = "js" | "jsx" | "ts" | "tsx" | "json" | "toml" | "file" | "napi" | "wasm" | "text" | "css" | "html";
+type Define = Record<string, string>;
+type Sourcemap = "none" | "linked" | "inline" | "external" | "linked" | boolean;
+type Format = "esm" | "cjs" | "iife";
+type Target = "bun" | "node" | "browser";
+type External = (string | RegExp)[];
+type Env = "inline" | "disable" | `${string}*` | Record<string, string>;
+interface BuildOptions {
+	/**
+	* Name of the build configuration
+	* Used for logging and identification purposes
+	*/
+	name?: string;
+	/**
+	* Entry point files for the build
+	*
+	* This can be:
+	* - A string path to a file
+	* - An array of file paths
+	*
+	* @see https://bunup.dev/docs/#entry-points
+	*/
+	entry: string | string[];
+	/**
+	* Output directory for the bundled files
+	* Defaults to 'dist' if not specified
+	*/
+	outDir: string;
+	/**
+	* Output formats for the bundle
+	* Can include 'esm', 'cjs', and/or 'iife'
+	* Defaults to ['cjs'] if not specified
+	*/
+	format: Format[];
+	/**
+	* Whether to enable all minification options
+	* When true, enables minifyWhitespace, minifyIdentifiers, and minifySyntax
+	*/
+	minify?: boolean;
+	/**
+	* Whether to enable code splitting
+	* Defaults to true for ESM format, false for CJS format
+	*/
+	splitting?: boolean;
+	/**
+	* Whether to minify whitespace in the output
+	* Removes unnecessary whitespace to reduce file size
+	*/
+	minifyWhitespace?: boolean;
+	/**
+	* Whether to minify identifiers in the output
+	* Renames variables and functions to shorter names
+	*/
+	minifyIdentifiers?: boolean;
+	/**
+	* Whether to minify syntax in the output
+	* Optimizes code structure for smaller file size
+	*/
+	minifySyntax?: boolean;
+	/**
+	* Whether to watch for file changes and rebuild automatically
+	*/
+	watch?: boolean;
+	/**
+	* Whether to generate TypeScript declaration files (.d.ts)
+	* When set to true, generates declaration files for all entry points
+	* Can also be configured with DtsOptions for more control
+	*/
+	dts?: boolean | (Pick<GenerateDtsOptions, "resolve" | "splitting" | "minify"> & {
+		entry?: string | string[]
+	});
+	/**
+	* Path to a preferred tsconfig.json file to use for declaration generation
+	*
+	* If not specified, the tsconfig.json in the project root will be used.
+	* This option allows you to use a different TypeScript configuration
+	* specifically for declaration file generation.
+	*
+	* @example
+	* preferredTsconfigPath: './tsconfig.build.json'
+	*/
+	preferredTsconfigPath?: string;
+	/**
+	* External packages that should not be bundled
+	* Useful for dependencies that should be kept as external imports
+	*/
+	external?: External;
+	/**
+	* Packages that should be bundled even if they are in external
+	* Useful for dependencies that should be included in the bundle
+	*/
+	noExternal?: External;
+	/**
+	* The target environment for the bundle.
+	* Can be 'browser', 'bun', 'node', etc.
+	* Defaults to 'node' if not specified.
+	*
+	* Bun target is for generating bundles that are intended to be run by the Bun runtime. In many cases,
+	* it isn't necessary to bundle server-side code; you can directly execute the source code
+	* without modification. However, bundling your server code can reduce startup times and
+	* improve running performance.
+	*
+	* All bundles generated with `target: "bun"` are marked with a special `// @bun` pragma, which
+	* indicates to the Bun runtime that there's no need to re-transpile the file before execution.
+	*/
+	target?: Target;
+	/**
+	* Whether to clean the output directory before building
+	* When true, removes all files in the outDir before starting a new build
+	* Defaults to true if not specified
+	*/
+	clean?: boolean;
+	/**
+	* Specifies the type of sourcemap to generate
+	* Can be 'none', 'linked', 'external', or 'inline'
+	* Can also be a boolean - when true, it will use 'inline'
+	*
+	* @see https://bun.sh/docs/bundler#sourcemap
+	*
+	* @default 'none'
+	*
+	* @example
+	* sourcemap: 'linked'
+	* // or
+	* sourcemap: true // equivalent to 'inline'
+	*/
+	sourcemap?: Sourcemap;
+	/**\\n\\t* Define global constants for the build\\n\\t* These values will be replaced at build time\\n\\t*\\n\\t* @see https://bun.sh/docs/bundler#define\\n\\t*\\n\\t* @example\\n\\t* define: {\\n\\t*   'process.env.NODE_ENV': '"production"',\\n\\t*   'PACKAGE_VERSION': '"1.0.0"'\\n\\t* }\\n\\t*/
+	define?: Define;
+	/**
+	* A callback function that runs after the build process completes
+	* This can be used for custom post-build operations like copying files,
+	* running additional tools, or logging build information
+	*
+	* If watch mode is enabled, this callback runs after each rebuild
+	*
+	* @param options The build options that were used
+	*/
+	onSuccess?: (options: Partial<BuildOptions>) => MaybePromise<void>;
+	/**\\n\\t* A banner to be added to the final bundle, this can be a directive like "use client" for react or a comment block such as a license for the code.\\n\\t*\\n\\t* @see https://bun.sh/docs/bundler#banner\\n\\t*\\n\\t* @example\\n\\t* banner: '"use client";'\\n\\t*/
+	banner?: string;
+	/**
+	* A footer to be added to the final bundle, this can be something like a comment block for a license or just a fun easter egg.
+	*
+	* @see https://bun.sh/docs/bundler#footer
+	*
+	* @example
+	* footer: '// built with love in SF'
+	*/
+	footer?: string;
+	/**
+	* Remove function calls from a bundle. For example, `drop: ["console"]` will remove all calls to `console.log`. Arguments to calls will also be removed, regardless of if those arguments may have side effects. Dropping `debugger` will remove all `debugger` statements.
+	*
+	* @see https://bun.sh/docs/bundler#drop
+	*
+	* @example
+	* drop: ["console", "debugger", "anyIdentifier.or.propertyAccess"]
+	*/
+	drop?: string[];
+	/**
+	* A map of file extensions to [built-in loader names](https://bun.sh/docs/bundler/loaders#built-in-loaders). This can be used to quickly customize how certain files are loaded.
+	*
+	* @see https://bun.sh/docs/bundler#loader
+	*
+	* @example
+	* loader: {
+	*   ".png": "dataurl",
+	*   ".txt": "file",
+	* }
+	*/
+	loader?: { [k in string] : Loader };
+	/**
+	* Generate bytecode for the output. This can dramatically improve cold start times, but will make the final output larger and slightly increase memory usage.
+	*
+	* Bytecode is currently only supported for CommonJS (format: "cjs").
+	*
+	* Must be target: "bun"
+	*
+	* @see https://bun.sh/docs/bundler#bytecode
+	*
+	* @default false
+	*/
+	bytecode?: boolean;
+	/**
+	* Disable logging during the build process. When set to true, no logs will be printed to the console.
+	*
+	* @default false
+	*/
+	silent?: boolean;
+	/**
+	* You can specify a prefix to be added to specific import paths in your bundled code
+	*
+	* Used for assets, external modules, and chunk files when splitting is enabled
+	*
+	* @see https://bunup.dev/docs#public-path for more information
+	*
+	* @example
+	* publicPath: 'https://cdn.example.com/'
+	*/
+	publicPath?: string;
+	/**
+	* Controls how environment variables are handled during bundling.
+	*
+	* Can be one of:
+	* - `"inline"`: Replaces all `process.env.FOO` references in your code with the actual values
+	*   of those environment variables at the time the build runs.
+	* - `"disable"`: Disables environment variable injection entirely, leaving `process.env.*` as-is.
+	* - A string ending in `*`: Only inlines environment variables matching the given prefix.
+	*   For example, `"MY_PUBLIC_*"` will inline variables like `MY_PUBLIC_API_URL`.
+	* - An object of key-value pairs: Replaces both `process.env.KEY` and `import.meta.env.KEY`
+	*   with the provided values, regardless of the runtime environment.
+	*
+	* Note: Values are injected at build time. Secrets or private keys should be excluded
+	* from inlining when targeting browser environments.
+	*
+	* @see https://bun.sh/docs/bundler#env to learn more about inline, disable, prefix, and object modes
+	*
+	* @example
+	* // Inline all environment variables available at build time
+	* env: "inline"
+	*
+	* // Disable all environment variable injection
+	* env: "disable"
+	*
+	* // Only inline environment variables with a specific prefix
+	* env: "PUBLIC_*"
+	*
+	* // Provide specific environment variables manually
+	* env: { API_URL: "https://api.example.com", DEBUG: "false" }
+	*/
+	env?: Env;
+	/**
+	* Ignore dead code elimination/tree-shaking annotations such as @__PURE__ and package.json
+	* "sideEffects" fields. This should only be used as a temporary workaround for incorrect
+	* annotations in libraries.
+	*/
+	ignoreDCEAnnotations?: boolean;
+	/**
+	* Force emitting @__PURE__ annotations even if minify.whitespace is true.
+	*/
+	emitDCEAnnotations?: boolean;
+	/**\\n\\t* Plugins to extend the build process functionality\\n\\t*\\n\\t* The Plugin type uses a discriminated union pattern with the 'type' field\\n\\t* to support different plugin systems. Both "bun" and "bunup" plugins are supported.\\n\\t*\\n\\t* Each plugin type has its own specific plugin implementation:\\n\\t* - "bun": Uses Bun's native plugin system (BunPlugin)\\n\\t* - "bunup": Uses bunup's own plugin system with lifecycle hooks\\n\\t*\\n\\t* This architecture allows for extensibility as more plugin systems are added.\\n\\t*\\n\\t* @see https://bunup.dev/docs/advanced/plugin-development for more information on plugins\\n\\t*\\n\\t* @example\\n\\t* plugins: [\\n\\t*   {\\n\\t*     type: "bun",\\n\\t*     plugin: myBunPlugin()\\n\\t*   },\\n\\t*   {\\n\\t*     type: "bunup",\\n\\t*     hooks: {\\n\\t*       onBuildStart: (options) => {\\n\\t*         console.log('Build started with options:', options)\\n\\t*       },\\n\\t*       onBuildDone: ({ options, output }) => {\\n\\t*         console.log('Build completed with output:', output)\\n\\t*       }\\n\\t*     }\\n\\t*   }\\n\\t* ]\\n\\t*/
+	plugins?: Plugin[];
+}
 declare function build(partialOptions: Partial<BuildOptions>, rootDir?: string): Promise<void>;
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: DefineWorkspaceItem[]): DefineWorkspaceItem[];

package/dist/index.js

@@ -1,10 +1,10 @@
 // @bun
 import {
   build
-} from "./chunk-2hchnc6a.js";
-import"./chunk-0e6rexd1.js";
+} from "./chunk-wav05ehp.js";
+import"./chunk-0j56xynx.js";
 import"./chunk-gh7z7s46.js";
-import"./chunk-w9q3brxd.js";
+import"./chunk-2g0gpaee.js";
 // src/define.ts
 function defineConfig(options) {
   return options;