robuild 0.0.13 → 0.0.15

package/dist/_chunks/{build-C9gSlxzR.mjs → build-BzBhuQnI.mjs}

@@ -1,14 +1,13 @@
 import { builtinModules } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { consola } from "consola";
 import { colors } from "consola/utils";
 import prettyBytes from "pretty-bytes";
 import { cp, mkdir, readFile, readdir, symlink, writeFile } from "node:fs/promises";
-import { defu } from "defu";
+import { consola } from "consola";
 import { resolveModulePath } from "exsolve";
 import { parseSync } from "oxc-parser";
-import { rolldown } from "rolldown";
+import { rolldown, watch } from "rolldown";
 import { dts } from "rolldown-plugin-dts";
 import { existsSync, promises, readdirSync, statSync } from "node:fs";
 import { glob } from "glob";
@@ -20,8 +19,6 @@ import { transform } from "oxc-transform";
 import { glob as glob$1 } from "tinyglobby";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import { watch } from "chokidar";
-import "minimatch";
 
 //#region src/features/advanced-build.ts
 /**
@@ -39,9 +36,10 @@ function createSkipNodeModulesPlugin(options) {
 	};
 	return {
 		name: "skip-node-modules",
-		resolveId: async (id) => {
+		resolveId: async (id, importer) => {
 			if (shouldInline(id)) return null;
-			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/")) return {
+			if (!importer) return null;
+			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\\")) return {
 				id,
 				external: true
 			};
@@ -53,7 +51,7 @@ function createSkipNodeModulesPlugin(options) {
 * Unbundle mode: preserve file structure without bundling
 */
 async function unbundleTransform(ctx, entry) {
-	const inputDir = join(ctx.pkgDir, entry.input);
+	const inputDir = isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input);
 	const outputDir = join(ctx.pkgDir, entry.outDir || "dist");
 	await processDirectoryUnbundled(inputDir, outputDir, entry);
 }
@@ -101,7 +99,7 @@ async function processFileUnbundled(inputPath, outputPath, entry) {
 /**
 * Transform imports for unbundle mode
 */
-function transformImportsForUnbundle(content, filePath, entry) {
+function transformImportsForUnbundle(content, _filePath, entry) {
 	let transformedContent = content;
 	transformedContent = transformedContent.replace(/from\s+['"]([^'"]+)['"]/g, (match, importPath) => {
 		if (importPath.startsWith(".")) {
@@ -231,11 +229,11 @@ function createGlobImportPlugin(options = {}) {
 			let transformedCode = code;
 			while ((match = globImportRegex.exec(code)) !== null) {
 				hasGlobImports = true;
-				const [fullMatch, quote, pattern, optionsStr] = match;
+				const [fullMatch, , pattern, optionsStr] = match;
 				let globOptions = {};
 				if (optionsStr) try {
 					globOptions = parseGlobOptions(optionsStr);
-				} catch (error) {
+				} catch {
 					console.warn("Failed to parse glob options:", optionsStr);
 				}
 				const isEager = globOptions.eager ?? eager;
@@ -261,7 +259,7 @@ async function generateGlobImport(pattern, importer, eager, asUrls, allowedPatte
 	try {
 		const absolutePattern = resolve(importerDir, pattern);
 		files = await glob(absolutePattern, { ignore: ["**/node_modules/**", "**/.git/**"] });
-	} catch (error) {
+	} catch {
 		if (pattern.includes("*.js")) files = [resolve(importerDir, pattern.replace("*", "module1")), resolve(importerDir, pattern.replace("*", "module2"))];
 	}
 	if (eager) return generateEagerImport(files, importerDir, asUrls);
@@ -345,7 +343,7 @@ function addHashToFilename(filename, content, hashLength = 8) {
 * Check if filename already has hash
 */
 function hasHash(filename) {
-	return /-[a-f0-9]{8}(\.|$)/.test(filename);
+	return /-[a-f0-9]{8}(?:\.|$)/.test(filename);
 }
 
 //#endregion
@@ -411,7 +409,12 @@ async function transformWithLoader(filePath, content, loader, options) {
 		case "jsx":
 		case "ts":
 		case "tsx": return content;
-		case "json": return `export default ${content}`;
+		case "json": try {
+			const parsed = JSON.parse(content);
+			return `export default ${JSON.stringify(parsed)}`;
+		} catch {
+			return `export default ${JSON.stringify(content)}`;
+		}
 		case "css": return transformCssContent(content, options);
 		case "text": return `export default ${JSON.stringify(content)}`;
 		case "file": return transformFileContent(filePath, options);
@@ -447,7 +450,7 @@ function transformFileContent(filePath, options) {
 /**
 * Transform file content to data URL
 */
-function transformDataUrlContent(filePath, content, options) {
+function transformDataUrlContent(filePath, content, _options) {
 	const ext = extname(filePath).toLowerCase();
 	const mimeType = getMimeType(ext);
 	const base64 = Buffer.from(content).toString("base64");
@@ -457,7 +460,7 @@ function transformDataUrlContent(filePath, content, options) {
 /**
 * Transform binary file content
 */
-function transformBinaryContent(filePath, options) {
+function transformBinaryContent(filePath, _options) {
 	const fileName = filePath.split("/").pop() || "binary";
 	return `export default ${JSON.stringify(fileName)}`;
 }
@@ -467,7 +470,7 @@ function transformBinaryContent(filePath, options) {
 function extractCssClassNames(content) {
 	const classRegex = /\.([a-z_-][\w-]*)/gi;
 	const matches = content.match(classRegex) || [];
-	return [...new Set(matches.map((match) => match.slice(1)))];
+	return Array.from(new Set(matches.map((match) => match.slice(1))));
 }
 /**
 * Get MIME type for file extension
@@ -508,13 +511,15 @@ function createLoaderPlugin(loaders) {
 	return {
 		name: "loaders",
 		load: async (id) => {
+			const ext = extname(id);
 			const loader = getLoaderForFile(id, loaders);
 			if (loader === "js" || loader === "jsx" || loader === "ts" || loader === "tsx") return null;
+			if (loader === "json" && !loaders?.[ext]) return null;
 			try {
 				const content = await readFile(id, "utf-8");
-				const options = loaders?.[extname(id)]?.options;
+				const options = loaders?.[ext]?.options;
 				return await transformWithLoader(id, content, loader, options);
-			} catch (error) {
+			} catch {
 				return null;
 			}
 		}
@@ -522,111 +527,156 @@ function createLoaderPlugin(loaders) {
 }
 
 //#endregion
-//#region src/features/plugins.ts
+//#region src/features/plugin-manager.ts
 /**
-* Plugin manager for handling plugin lifecycle and execution
+* Simplified plugin manager that leverages rolldown's plugin system
 */
-var PluginManager = class {
+var RobuildPluginManager = class {
 	plugins = [];
 	context;
-	constructor(config, entry) {
+	constructor(config, entry, pkgDir) {
 		this.context = {
 			config,
 			entry,
-			plugins: config.plugins || [],
-			hooks: config.hooks || {}
+			pkgDir,
+			outDir: entry.outDir || "dist",
+			format: entry.format || "esm",
+			platform: entry.platform || "node",
+			target: entry.target || "es2022"
 		};
-		this.plugins = config.plugins || [];
+		this.plugins = this.normalizePlugins(config.plugins || []);
 	}
 	/**
-	* Initialize all plugins
+	* Normalize plugin options to RobuildPlugin instances
 	*/
-	async initialize() {
-		for (const plugin of this.plugins) if (plugin.setup) {
-			const pluginBuild = this.createPluginBuild();
-			await plugin.setup(pluginBuild);
+	normalizePlugins(pluginOptions) {
+		return pluginOptions.map((pluginOption) => this.normalizePlugin(pluginOption));
+	}
+	/**
+	* Normalize a single plugin option
+	*/
+	normalizePlugin(pluginOption) {
+		if (typeof pluginOption === "function") return this.normalizePlugin(pluginOption());
+		if (typeof pluginOption === "object" && pluginOption !== null) {
+			if (this.isRobuildPlugin(pluginOption)) return pluginOption;
+			if (this.isRolldownPlugin(pluginOption)) return this.adaptRolldownPlugin(pluginOption);
+			if (this.isVitePlugin(pluginOption)) return this.adaptVitePlugin(pluginOption);
+			if (this.isUnplugin(pluginOption)) return this.adaptUnplugin(pluginOption);
+			return this.adaptRolldownPlugin(pluginOption);
 		}
+		throw new Error(`Invalid plugin option: ${typeof pluginOption}`);
+	}
+	/**
+	* Check if plugin is already a RobuildPlugin
+	*/
+	isRobuildPlugin(plugin) {
+		return plugin.meta?.robuild === true || plugin.robuildSetup || plugin.robuildBuildStart || plugin.robuildBuildEnd;
 	}
 	/**
-	* Execute a specific hook across all plugins
+	* Check if plugin is a rolldown/rollup plugin
 	*/
-	async executeHook(hookName, ...args) {
-		const results = [];
-		for (const plugin of this.plugins) {
-			const hook = plugin[hookName];
-			if (typeof hook === "function") try {
-				const result = await hook.apply(plugin, args);
-				results.push(result);
-			} catch (error) {
-				console.error(`Plugin ${plugin.name} hook ${hookName} failed:`, error);
-				throw error;
+	isRolldownPlugin(plugin) {
+		return plugin.name && (plugin.buildStart || plugin.buildEnd || plugin.resolveId || plugin.load || plugin.transform || plugin.generateBundle || plugin.writeBundle);
+	}
+	/**
+	* Check if plugin is a Vite plugin
+	*/
+	isVitePlugin(plugin) {
+		return plugin.config || plugin.configResolved || plugin.configureServer || plugin.meta?.vite === true;
+	}
+	/**
+	* Check if plugin is an Unplugin
+	*/
+	isUnplugin(plugin) {
+		return plugin.unplugin === true || plugin.meta?.unplugin === true;
+	}
+	/**
+	* Adapt rolldown plugin to RobuildPlugin
+	*/
+	adaptRolldownPlugin(plugin) {
+		return {
+			...plugin,
+			meta: {
+				...plugin.meta,
+				framework: "rolldown",
+				robuild: true,
+				rollup: true
 			}
-		}
-		return results;
+		};
 	}
 	/**
-	* Create plugin build context for setup
+	* Adapt Vite plugin to RobuildPlugin
 	*/
-	createPluginBuild() {
-		const resolveCallbacks = [];
-		const loadCallbacks = [];
-		const transformCallbacks = [];
+	adaptVitePlugin(plugin) {
 		return {
-			onResolve: (options, callback) => {
-				resolveCallbacks.push({
-					...options,
-					callback
-				});
-			},
-			onLoad: (options, callback) => {
-				loadCallbacks.push({
-					...options,
-					callback
-				});
-			},
-			onTransform: (options, callback) => {
-				transformCallbacks.push({
-					...options,
-					callback
-				});
-			},
-			resolve: async (path, options) => {
-				for (const { filter, callback } of resolveCallbacks) if (filter.test(path)) {
-					const result = await callback({
-						path,
-						...options
-					});
-					if (result) return result;
-				}
-				return null;
-			},
-			getConfig: () => this.context.config
+			...plugin,
+			meta: {
+				...plugin.meta,
+				framework: "vite",
+				robuild: true,
+				vite: true
+			}
 		};
 	}
 	/**
-	* Get all plugins
+	* Adapt Unplugin to RobuildPlugin
 	*/
-	getPlugins() {
-		return this.plugins;
+	adaptUnplugin(plugin) {
+		return {
+			...plugin,
+			meta: {
+				...plugin.meta,
+				framework: "unplugin",
+				robuild: true,
+				unplugin: true,
+				rollup: true,
+				vite: true,
+				webpack: true,
+				esbuild: true
+			}
+		};
 	}
 	/**
-	* Add a plugin
+	* Initialize robuild-specific plugin hooks
 	*/
-	addPlugin(plugin) {
-		this.plugins.push(plugin);
-		this.context.plugins = this.plugins;
+	async initializeRobuildHooks() {
+		for (const plugin of this.plugins) if (plugin.robuildSetup) await plugin.robuildSetup(this.context);
 	}
 	/**
-	* Remove a plugin by name
+	* Execute robuild buildStart hooks
 	*/
-	removePlugin(name) {
-		const index = this.plugins.findIndex((p) => p.name === name);
-		if (index !== -1) {
-			this.plugins.splice(index, 1);
-			this.context.plugins = this.plugins;
-			return true;
-		}
-		return false;
+	async executeRobuildBuildStart() {
+		for (const plugin of this.plugins) if (plugin.robuildBuildStart) await plugin.robuildBuildStart(this.context);
+	}
+	/**
+	* Execute robuild buildEnd hooks
+	*/
+	async executeRobuildBuildEnd(result) {
+		for (const plugin of this.plugins) if (plugin.robuildBuildEnd) await plugin.robuildBuildEnd(this.context, result);
+	}
+	/**
+	* Get rolldown-compatible plugins for direct use
+	*/
+	getRolldownPlugins() {
+		return this.plugins.map((plugin) => {
+			const { robuildSetup, robuildBuildStart, robuildBuildEnd,...rolldownPlugin } = plugin;
+			return rolldownPlugin;
+		});
+	}
+	/**
+	* Get all plugins
+	*/
+	getPlugins() {
+		return this.plugins;
+	}
+	/**
+	* Update context (useful when build parameters change)
+	*/
+	updateContext(updates) {
+		this.context = {
+			...this.context,
+			...updates
+		};
 	}
 };
 
@@ -742,7 +792,7 @@ function createShimsPlugin(config = true) {
 	return {
 		name: "shims",
 		transform: async (code, id) => {
-			if (!/\.(js|mjs|cjs|ts|mts|cts|jsx|tsx)$/.test(id)) return null;
+			if (!/\.(?:js|mjs|cjs|ts|mts|cts|jsx|tsx)$/.test(id)) return null;
 			const needs = detectShimNeeds(code);
 			if (!needs.needsDirname && !needs.needsRequire && !needs.needsExports && !needs.needsEnv) return null;
 			const transformedCode = transformWithShims(code, shimsConfig);
@@ -751,88 +801,6 @@ function createShimsPlugin(config = true) {
 	};
 }
 
-//#endregion
-//#region src/utils.ts
-function fmtPath(path) {
-	return resolve(path).replace(process.cwd(), ".");
-}
-function analyzeDir(dir) {
-	if (Array.isArray(dir)) {
-		let totalSize$1 = 0;
-		let totalFiles = 0;
-		for (const d of dir) {
-			const { size, files: files$1 } = analyzeDir(d);
-			totalSize$1 += size;
-			totalFiles += files$1;
-		}
-		return {
-			size: totalSize$1,
-			files: totalFiles
-		};
-	}
-	let totalSize = 0;
-	const files = readdirSync(dir, {
-		withFileTypes: true,
-		recursive: true
-	});
-	for (const file of files) {
-		const fullPath = join(file.parentPath, file.name);
-		if (file.isFile()) {
-			const { size } = statSync(fullPath);
-			totalSize += size;
-		}
-	}
-	return {
-		size: totalSize,
-		files: files.length
-	};
-}
-async function distSize(dir, entry) {
-	const build$1 = await rolldown({
-		input: join(dir, entry),
-		plugins: [],
-		platform: "neutral",
-		external: (id) => id[0] !== "." && !id.startsWith(dir)
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
-	const code = output[0].code;
-	const { code: minified } = await minify(entry, code);
-	return {
-		size: Buffer.byteLength(code),
-		minSize: Buffer.byteLength(minified),
-		minGzipSize: gzipSync(minified).length
-	};
-}
-async function sideEffectSize(dir, entry) {
-	const virtualEntry = {
-		name: "virtual-entry",
-		async resolveId(id, importer, opts) {
-			if (id === "#entry") return { id };
-			const resolved = await this.resolve(id, importer, opts);
-			if (!resolved) return null;
-			resolved.moduleSideEffects = null;
-			return resolved;
-		},
-		load(id) {
-			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
-		}
-	};
-	const build$1 = await rolldown({
-		input: "#entry",
-		platform: "neutral",
-		external: (id) => id[0] !== "." && !id.startsWith(dir),
-		plugins: [virtualEntry]
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
-	if (process.env.INSPECT_BUILD) {
-		console.log("---------[side effects]---------");
-		console.log(entry);
-		console.log(output[0].code);
-		console.log("-------------------------------");
-	}
-	return Buffer.byteLength(output[0].code.trim());
-}
-
 //#endregion
 //#region src/features/node-protocol.ts
 /**
@@ -925,7 +893,7 @@ function transformNodeProtocol(code, nodeProtocol) {
 }
 
 //#endregion
-//#region src/builders/plugins/node-protocol.ts
+//#region src/plugins/node-protocol.ts
 /**
 * Rolldown plugin for Node.js protocol handling
 */
@@ -943,7 +911,7 @@ function nodeProtocolPlugin(nodeProtocol) {
 }
 
 //#endregion
-//#region src/builders/plugins/shebang.ts
+//#region src/plugins/shebang.ts
 const SHEBANG_RE = /^#![^\n]*/;
 function shebangPlugin() {
 	return {
@@ -966,6 +934,88 @@ async function makeExecutable(filePath) {
 	await promises.chmod(filePath, 493).catch(() => {});
 }
 
+//#endregion
+//#region src/utils.ts
+function fmtPath(path) {
+	return resolve(path).replace(process.cwd(), ".");
+}
+function analyzeDir(dir) {
+	if (Array.isArray(dir)) {
+		let totalSize$1 = 0;
+		let totalFiles = 0;
+		for (const d of dir) {
+			const { size, files: files$1 } = analyzeDir(d);
+			totalSize$1 += size;
+			totalFiles += files$1;
+		}
+		return {
+			size: totalSize$1,
+			files: totalFiles
+		};
+	}
+	let totalSize = 0;
+	const files = readdirSync(dir, {
+		withFileTypes: true,
+		recursive: true
+	});
+	for (const file of files) {
+		const fullPath = join(file.parentPath, file.name);
+		if (file.isFile()) {
+			const { size } = statSync(fullPath);
+			totalSize += size;
+		}
+	}
+	return {
+		size: totalSize,
+		files: files.length
+	};
+}
+async function distSize(dir, entry) {
+	const build$1 = await rolldown({
+		input: join(dir, entry),
+		plugins: [],
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir)
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	const code = output[0].code;
+	const { code: minified } = minify(entry, code);
+	return {
+		size: Buffer.byteLength(code),
+		minSize: Buffer.byteLength(minified),
+		minGzipSize: gzipSync(minified).length
+	};
+}
+async function sideEffectSize(dir, entry) {
+	const virtualEntry = {
+		name: "virtual-entry",
+		async resolveId(id, importer, opts) {
+			if (id === "#entry") return { id };
+			const resolved = await this.resolve(id, importer, opts);
+			if (!resolved) return null;
+			resolved.moduleSideEffects = null;
+			return resolved;
+		},
+		load(id) {
+			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
+		}
+	};
+	const build$1 = await rolldown({
+		input: "#entry",
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir),
+		plugins: [virtualEntry]
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	if (process.env.INSPECT_BUILD) {
+		console.log("---------[side effects]---------");
+		console.log(entry);
+		console.log(output[0].code);
+		console.log("-------------------------------");
+	}
+	return Buffer.byteLength(output[0].code.trim());
+}
+
 //#endregion
 //#region src/builders/bundle.ts
 /**
@@ -1020,22 +1070,29 @@ async function cleanOutputDir$1(projectRoot, outDir, cleanPaths) {
 	}
 }
 async function rolldownBuild(ctx, entry, hooks, config) {
-	const inputs = normalizeBundleInputs(entry.input, ctx);
-	const pluginManager = new PluginManager(config || {}, entry);
-	await pluginManager.initialize();
+	const entryInput = entry.input || entry.entry;
+	if (!entryInput) throw new Error("Entry input is required");
+	const inputs = normalizeBundleInputs(entryInput, ctx);
+	const pluginManager = new RobuildPluginManager(config || {}, entry, ctx.pkgDir);
+	await pluginManager.initializeRobuildHooks();
 	const formats = Array.isArray(entry.format) ? entry.format : [entry.format || "esm"];
 	const platform = entry.platform || "node";
 	const target = entry.target || "es2022";
 	const outDir = entry.outDir || "dist";
 	const fullOutDir = resolve(ctx.pkgDir, outDir);
 	const isMultiFormat = formats.length > 1;
-	await pluginManager.executeHook("buildStart", {
-		inputs,
-		formats,
+	pluginManager.updateContext({
+		format: formats,
 		platform,
-		target
+		target,
+		outDir: fullOutDir
 	});
+	await pluginManager.executeRobuildBuildStart();
 	await cleanOutputDir$1(ctx.pkgDir, fullOutDir, entry.clean ?? true);
+	if (entry.dtsOnly) {
+		consola.info("Running in dtsOnly mode - only generating declaration files");
+		entry.dts = entry.dts === false ? true : entry.dts || true;
+	}
 	if (entry.stub) {
 		for (const [distName, srcPath] of Object.entries(inputs)) {
 			const distPath = join(ctx.pkgDir, "dist", `${distName}.mjs`);
@@ -1070,7 +1127,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			externalDeps = externalDeps.filter((dep) => {
 				if (typeof dep === "string") return !excludedNames.has(dep);
 				if (dep instanceof RegExp) {
-					for (const name of excludedNames) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
+					for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
 					return true;
 				}
 				return true;
@@ -1099,13 +1156,12 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 	const defineOptions = {};
 	if (entry.env) for (const [key, value] of Object.entries(entry.env)) defineOptions[`process.env.${key}`] = JSON.stringify(value);
 	if (entry.define) for (const [key, value] of Object.entries(entry.define)) defineOptions[key] = value;
-	const rolldownPlugins = [];
-	rolldownPlugins.push(shebangPlugin(), nodeProtocolPlugin(entry.nodeProtocol || false));
+	const rolldownPlugins = [shebangPlugin(), nodeProtocolPlugin(entry.nodeProtocol || false)];
 	if (config?.globImport?.enabled) {
 		const globPlugin = createGlobImportPlugin(config.globImport);
 		if (globPlugin.transform) rolldownPlugins.push({
 			name: "glob-import",
-			transform: async (code, id) => {
+			transform: async (code, id, _meta) => {
 				const result = await globPlugin.transform(code, id);
 				return result ? { code: result } : null;
 			}
@@ -1122,7 +1178,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		const shimsPlugin = createShimsPlugin(entry.shims);
 		if (shimsPlugin.transform) rolldownPlugins.push({
 			name: "shims",
-			transform: async (code, id) => {
+			transform: async (code, id, _meta) => {
 				const result = await shimsPlugin.transform(code, id);
 				return result ? { code: result } : null;
 			}
@@ -1135,18 +1191,8 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			resolveId: skipPlugin.resolveId
 		});
 	}
-	if (config?.plugins) {
-		for (const plugin of pluginManager.getPlugins()) if (plugin.transform || plugin.resolveId || plugin.load) rolldownPlugins.push({
-			name: plugin.name,
-			resolveId: plugin.resolveId,
-			load: plugin.load,
-			transform: plugin.transform ? async (code, id) => {
-				const result = await plugin.transform(code, id);
-				return result ? typeof result === "string" ? { code: result } : result : null;
-			} : void 0
-		});
-	}
-	const baseRolldownConfig = defu(entry.rolldown, {
+	rolldownPlugins.push(...pluginManager.getRolldownPlugins());
+	const robuildGeneratedConfig = {
 		cwd: ctx.pkgDir,
 		input: inputs,
 		plugins: rolldownPlugins,
@@ -1155,7 +1201,15 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		define: defineOptions,
 		resolve: { alias: entry.alias || {} },
 		transform: { target }
-	});
+	};
+	if (entry.treeshake !== void 0) if (typeof entry.treeshake === "boolean") robuildGeneratedConfig.treeshake = entry.treeshake;
+	else robuildGeneratedConfig.treeshake = entry.treeshake;
+	const { output: userOutputConfig, plugins: userPlugins,...userRolldownConfig } = entry.rolldown || {};
+	const baseRolldownConfig = {
+		...robuildGeneratedConfig,
+		...userRolldownConfig,
+		plugins: [...rolldownPlugins, ...Array.isArray(userPlugins) ? userPlugins : userPlugins ? [userPlugins] : []]
+	};
 	await hooks.rolldownConfig?.(baseRolldownConfig, ctx);
 	const allOutputEntries = [];
 	const filePathMap = /* @__PURE__ */ new Map();
@@ -1163,7 +1217,10 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		const rolldownFormat = formatToRolldownFormat(format);
 		const extension = getFormatExtension(format, platform, entry.fixedExtension);
 		const formatConfig = { ...baseRolldownConfig };
-		if (entry.dts !== false && format === "esm") formatConfig.plugins = [...formatConfig.plugins, ...dts({ ...entry.dts })];
+		if (entry.dts !== false && format === "esm") {
+			const dtsPlugins = dts({ ...entry.dts });
+			formatConfig.plugins = [...Array.isArray(formatConfig.plugins) ? formatConfig.plugins : [formatConfig.plugins], ...Array.isArray(dtsPlugins) ? dtsPlugins : [dtsPlugins]];
+		}
 		const res = await rolldown(formatConfig);
 		let formatOutDir = fullOutDir;
 		let entryFileName = `[name]${extension}`;
@@ -1179,7 +1236,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			formatOutDir = join(fullOutDir, "browser");
 			entryFileName = `[name].js`;
 		}
-		const outConfig = {
+		const robuildOutputConfig = {
 			dir: formatOutDir,
 			format: rolldownFormat,
 			entryFileNames: entryFileName,
@@ -1189,7 +1246,11 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			banner: resolveChunkAddon(entry.banner, format),
 			footer: resolveChunkAddon(entry.footer, format)
 		};
-		if (entry.sourcemap !== void 0) outConfig.sourcemap = entry.sourcemap;
+		if (entry.sourcemap !== void 0) robuildOutputConfig.sourcemap = entry.sourcemap;
+		const outConfig = {
+			...robuildOutputConfig,
+			...userOutputConfig || {}
+		};
 		await hooks.rolldownOutput?.(outConfig, res, ctx);
 		const { output } = await res.write(outConfig);
 		await res.close();
@@ -1242,7 +1303,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		}
 	}
 	if (entry.copy) await copyFiles(ctx.pkgDir, fullOutDir, entry.copy);
-	await pluginManager.executeHook("buildEnd", { allOutputEntries });
+	await pluginManager.executeRobuildBuildEnd({ allOutputEntries });
 	consola.log(`\n${allOutputEntries.map((o) => [
 		`${colors.magenta(`[bundle] `)}${colors.underline(fmtPath(filePathMap.get(o.name) || join(fullOutDir, o.name)))}`,
 		colors.dim(`${colors.bold("Size:")} ${prettyBytes(o.size)}, ${colors.bold(prettyBytes(o.minSize))} minified, ${prettyBytes(o.minGzipSize)} min+gzipped (Side effects: ${prettyBytes(o.sideEffectSize)})`),
@@ -1252,6 +1313,22 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 }
 function normalizeBundleInputs(input, ctx) {
 	const inputs = {};
+	if (typeof input === "object" && !Array.isArray(input)) {
+		for (const [name, src] of Object.entries(input)) {
+			const resolvedSrc = resolveModulePath(src, {
+				from: ctx.pkgDir,
+				extensions: [
+					".ts",
+					".js",
+					".mjs",
+					".cjs",
+					".json"
+				]
+			});
+			inputs[name] = resolvedSrc;
+		}
+		return inputs;
+	}
 	for (let src of Array.isArray(input) ? input : [input]) {
 		src = resolveModulePath(src, {
 			from: ctx.pkgDir,
@@ -1499,176 +1576,6 @@ async function transformModule(entryPath, entry) {
 	return transformed;
 }
 
-//#endregion
-//#region src/features/exports.ts
-/**
-* Generate package.json exports field based on build configuration
-*/
-async function generatePackageExports(packageRoot, buildConfig, exportsConfig = { enabled: true }) {
-	if (!exportsConfig.enabled) return {};
-	const exports = {};
-	const baseDir = exportsConfig.baseDir || "dist";
-	if (exportsConfig.custom) Object.assign(exports, exportsConfig.custom);
-	if (buildConfig.entries) for (const entry of buildConfig.entries) {
-		const exportEntries = await generateExportFromEntry(packageRoot, entry, baseDir, exportsConfig.includeTypes);
-		for (const exportEntry of exportEntries) exports[exportEntry.key] = createExportValue(exportEntry);
-	}
-	if (!exports["."] && !exports["./index"]) {
-		const mainExport = await findMainExport(packageRoot, baseDir);
-		if (mainExport) exports["."] = mainExport;
-	}
-	return exports;
-}
-/**
-* Generate export entries from a build entry
-*/
-async function generateExportFromEntry(packageRoot, entry, baseDir, includeTypes) {
-	const exports = [];
-	if (entry.type === "bundle") {
-		const exportKey = getExportKey(entry.input);
-		const exportEntry = { key: exportKey };
-		if (Array.isArray(entry.format)) for (const format of entry.format) {
-			const outputPath = getOutputPath(entry, format, baseDir);
-			assignFormatToExport(exportEntry, format, outputPath);
-		}
-		else if (entry.format) {
-			const outputPath = getOutputPath(entry, entry.format, baseDir);
-			assignFormatToExport(exportEntry, entry.format, outputPath);
-		}
-		if (includeTypes && entry.dts) {
-			const typesPath = getTypesPath(entry, baseDir);
-			exportEntry.types = typesPath;
-		}
-		exports.push(exportEntry);
-	} else if (entry.type === "transform") {
-		const transformExports = await discoverTransformExports(packageRoot, entry, baseDir, includeTypes);
-		exports.push(...transformExports);
-	}
-	return exports;
-}
-/**
-* Get export key from input path
-*/
-function getExportKey(input) {
-	if (input === "index.ts" || input === "src/index.ts") return ".";
-	let key = input.replace(/\.(ts|js|tsx|jsx)$/, "");
-	key = key.replace(/^src\//, "");
-	return key === "index" ? "." : `./${key}`;
-}
-/**
-* Get output path for a specific format
-*/
-function getOutputPath(entry, format, baseDir) {
-	const extension = getExtensionForFormat(format);
-	const basename$1 = getBasename(entry.input);
-	if (format === "cjs") return `./${baseDir}/cjs/${basename$1}${extension}`;
-	else if (format === "esm") return `./${baseDir}/${basename$1}${extension}`;
-	else return `./${baseDir}/${format}/${basename$1}${extension}`;
-}
-/**
-* Get file extension for format
-*/
-function getExtensionForFormat(format) {
-	switch (format) {
-		case "esm": return ".mjs";
-		case "cjs": return ".cjs";
-		case "iife":
-		case "umd": return ".js";
-		default: return ".js";
-	}
-}
-/**
-* Get basename from input path
-*/
-function getBasename(input) {
-	return input.replace(/\.(ts|js|tsx|jsx)$/, "").replace(/^src\//, "");
-}
-/**
-* Get types path for entry
-*/
-function getTypesPath(entry, baseDir) {
-	const basename$1 = getBasename(entry.input);
-	return `./${baseDir}/${basename$1}.d.ts`;
-}
-/**
-* Assign format-specific path to export entry
-*/
-function assignFormatToExport(exportEntry, format, path) {
-	switch (format) {
-		case "esm":
-			exportEntry.import = path;
-			break;
-		case "cjs":
-			exportEntry.require = path;
-			break;
-		default:
-			exportEntry.import = path;
-			break;
-	}
-}
-/**
-* Create export value from export entry
-*/
-function createExportValue(entry) {
-	const value = {};
-	if (entry.types) value.types = entry.types;
-	if (entry.import) value.import = entry.import;
-	if (entry.require) value.require = entry.require;
-	const keys = Object.keys(value);
-	if (keys.length === 1 && !entry.types) return value[keys[0]];
-	return value;
-}
-/**
-* Discover exports from transform entries
-*/
-async function discoverTransformExports(packageRoot, entry, baseDir, includeTypes) {
-	const exports = [];
-	const exportKey = getExportKey(entry.input);
-	const exportEntry = {
-		key: exportKey,
-		import: `./${baseDir}/${getBasename(entry.input)}.mjs`
-	};
-	if (includeTypes && entry.dts) exportEntry.types = getTypesPath(entry, baseDir);
-	exports.push(exportEntry);
-	return exports;
-}
-/**
-* Find main export file
-*/
-async function findMainExport(packageRoot, baseDir) {
-	const possibleMains = [
-		"index.mjs",
-		"index.js",
-		"index.cjs"
-	];
-	for (const main of possibleMains) try {
-		join(packageRoot, baseDir, main);
-		const value = {};
-		if (main.endsWith(".mjs")) value.import = `./${baseDir}/${main}`;
-		else if (main.endsWith(".cjs")) value.require = `./${baseDir}/${main}`;
-		else value.import = `./${baseDir}/${main}`;
-		return value;
-	} catch {
-		continue;
-	}
-	return null;
-}
-/**
-* Update package.json with generated exports
-*/
-async function updatePackageJsonExports(packageRoot, exports) {
-	const packageJsonPath = join(packageRoot, "package.json");
-	try {
-		const content = await readFile(packageJsonPath, "utf-8");
-		const packageJson = JSON.parse(content);
-		packageJson.exports = exports;
-		const updatedContent = `${JSON.stringify(packageJson, null, 2)}\n`;
-		await writeFile(packageJsonPath, updatedContent, "utf-8");
-	} catch (error) {
-		throw new Error(`Failed to update package.json: ${error}`);
-	}
-}
-
 //#endregion
 //#region src/features/logger.ts
 /**
@@ -1904,267 +1811,120 @@ function convertExternal(external) {
 }
 
 //#endregion
-//#region src/features/workspace.ts
-/**
-* Discover workspace packages based on patterns
-*/
-async function discoverWorkspacePackages(workspaceRoot, patterns = ["packages/*", "apps/*"]) {
-	const packages = [];
-	for (const pattern of patterns) {
-		const packagePaths = await glob(pattern, {
-			cwd: workspaceRoot,
-			onlyDirectories: true
-		});
-		for (const packagePath of packagePaths) {
-			const fullPath = resolve(workspaceRoot, packagePath);
-			const packageJsonPath = join(fullPath, "package.json");
-			try {
-				const packageJsonContent = await readFile(packageJsonPath, "utf-8");
-				const packageJson = JSON.parse(packageJsonContent);
-				packages.push({
-					name: packageJson.name || packagePath,
-					path: fullPath,
-					packageJson
-				});
-			} catch {
-				continue;
-			}
-		}
-	}
-	return packages;
+//#region src/watch.ts
+function normalizePath$1(path, resolveFrom) {
+	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
 }
 /**
-* Filter workspace packages based on filter patterns
+* Perform watch build using rolldown's built-in watch mode
 */
-function filterWorkspacePackages(packages, filter, exclude) {
-	let filtered = packages;
-	if (filter) {
-		const filters = Array.isArray(filter) ? filter : [filter];
-		filtered = filtered.filter((pkg) => filters.some((f) => matchesPattern(pkg.name, f) || matchesPattern(pkg.path, f)));
-	}
-	if (exclude) {
-		const excludes = Array.isArray(exclude) ? exclude : [exclude];
-		filtered = filtered.filter((pkg) => !excludes.some((e) => matchesPattern(pkg.name, e) || matchesPattern(pkg.path, e)));
+async function performWatchBuild(config, ctx, startTime) {
+	const { performBuild: performBuild$1 } = await import("./build-yfn0_Gzc.mjs");
+	await performBuild$1(config, ctx, startTime);
+	const bundleEntries = (config.entries || []).filter((entry) => {
+		if (typeof entry === "string") return !entry.endsWith("/");
+		return entry.type === "bundle";
+	});
+	if (bundleEntries.length > 0) await startRolldownWatch(ctx, bundleEntries);
+	else {
+		logger.warn("Transform-only watch mode not yet implemented with rolldown");
+		return new Promise(() => {});
 	}
-	return filtered;
-}
-/**
-* Check if a string matches a pattern (supports wildcards)
-*/
-function matchesPattern(str, pattern) {
-	const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\[([^\]]+)\]/g, "[$1]");
-	const regex = /* @__PURE__ */ new RegExp(`^${regexPattern}$`);
-	return regex.test(str);
 }
 /**
-* Load workspace configuration from package.json or workspace config file
+* Start rolldown watch mode for bundle entries
 */
-async function loadWorkspaceConfig(workspaceRoot) {
-	try {
-		const packageJsonPath = join(workspaceRoot, "package.json");
-		const packageJsonContent = await readFile(packageJsonPath, "utf-8");
-		const packageJson = JSON.parse(packageJsonContent);
-		if (packageJson.workspaces) {
-			const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || [];
-			return { packages: workspaces };
-		}
-		try {
-			const { load } = await import("js-yaml");
-			const pnpmWorkspacePath = join(workspaceRoot, "pnpm-workspace.yaml");
-			const pnpmWorkspaceContent = await readFile(pnpmWorkspacePath, "utf-8");
-			const pnpmWorkspace = load(pnpmWorkspaceContent);
-			if (pnpmWorkspace?.packages) return { packages: pnpmWorkspace.packages };
-		} catch {}
-		try {
-			const lernaJsonPath = join(workspaceRoot, "lerna.json");
-			const lernaJsonContent = await readFile(lernaJsonPath, "utf-8");
-			const lernaJson = JSON.parse(lernaJsonContent);
-			if (lernaJson.packages) return { packages: lernaJson.packages };
-		} catch {}
-		return null;
-	} catch {
-		return null;
+async function startRolldownWatch(ctx, bundleEntries) {
+	logger.info("🚧 Using rolldown built-in watch mode...");
+	const watchConfigs = [];
+	for (const rawEntry of bundleEntries) {
+		let entry;
+		if (typeof rawEntry === "string") {
+			const [input, outDir] = rawEntry.split(":");
+			entry = {
+				type: "bundle",
+				input,
+				outDir: outDir || "dist"
+			};
+		} else entry = rawEntry;
+		entry.input = Array.isArray(entry.input) ? entry.input.map((i) => normalizePath$1(i, ctx.pkgDir)) : normalizePath$1(entry.input, ctx.pkgDir);
+		const watchConfig = {
+			input: Array.isArray(entry.input) ? entry.input[0] : entry.input,
+			output: {
+				dir: entry.outDir,
+				format: "esm"
+			}
+		};
+		watchConfigs.push(watchConfig);
 	}
-}
-/**
-* Build workspace packages in dependency order
-*/
-async function buildWorkspacePackages(packages, buildFn) {
-	await Promise.all(packages.map(buildFn));
-}
-
-//#endregion
-//#region src/features/ignore-watch.ts
-/**
-* Normalize ignore patterns
-*/
-function normalizeIgnorePatterns(patterns) {
-	return patterns.map((pattern) => {
-		if (pattern.startsWith("./")) return pattern.slice(2);
-		if (pattern.startsWith("/")) return pattern.slice(1);
-		return pattern;
+	const watcher = watch(watchConfigs);
+	watcher.on("event", (event) => {
+		switch (event.code) {
+			case "START":
+				logger.info("🔄 Rebuilding...");
+				break;
+			case "BUNDLE_START":
+				logger.info("📦 Bundling...");
+				break;
+			case "BUNDLE_END":
+				logger.success("✅ Bundle complete");
+				break;
+			case "END":
+				logger.success("🎉 Watch rebuild complete");
+				break;
+			case "ERROR":
+				logger.error("❌ Build error:", event.error);
+				break;
+		}
 	});
+	const cleanup = async () => {
+		consola.info("🛑 Stopping watch mode...");
+		await watcher.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+	return new Promise(() => {});
 }
 
 //#endregion
-//#region src/watch.ts
-/**
-* Start watching files and rebuild on changes
-*/
-async function startWatch(config, ctx, buildFn) {
-	const watchOptions = config.watch || {};
-	if (!watchOptions.enabled) throw new Error("Watch mode is not enabled");
-	const watchCtx = {
-		config,
-		ctx,
-		buildFn,
-		isBuilding: false,
-		pendingRebuild: false
-	};
-	const watchPatterns = await getWatchPatterns(config, ctx, watchOptions);
-	const ignorePatterns = getIgnorePatterns(config, watchOptions);
-	consola.info(`👀 Starting watch mode...`);
-	consola.info(`📁 Watching: ${colors.dim(watchPatterns.join(", "))}`);
-	if (ignorePatterns.length > 0) consola.info(`🚫 Ignoring: ${colors.dim(ignorePatterns.join(", "))}`);
-	const delay = watchOptions.delay ?? 100;
-	if (delay > 0) consola.info(`⏱️  Rebuild delay: ${colors.dim(`${delay}ms`)}`);
-	const watcher = watch(watchPatterns, {
-		ignored: ignorePatterns,
-		ignoreInitial: watchOptions.ignoreInitial ?? false,
-		persistent: true,
-		followSymlinks: false,
-		cwd: ctx.pkgDir
-	});
-	watcher.on("change", (path) => handleFileChange(watchCtx, path, "changed"));
-	watcher.on("add", (path) => {
-		if (watchOptions.watchNewFiles !== false) handleFileChange(watchCtx, path, "added");
-	});
-	watcher.on("unlink", (path) => handleFileChange(watchCtx, path, "removed"));
-	watcher.on("error", (error) => {
-		consola.error("❌ Watch error:", error);
-	});
-	if (process.env.DEBUG) {
-		watcher.on("addDir", (path) => consola.debug(`📁 Directory added: ${path}`));
-		watcher.on("unlinkDir", (path) => consola.debug(`📁 Directory removed: ${path}`));
-	}
-	await new Promise((resolve$1) => {
-		watcher.on("ready", () => {
-			const watchedPaths = watcher.getWatched();
-			const totalFiles = Object.values(watchedPaths).reduce((sum, files) => sum + files.length, 0);
-			consola.success(`🚀 Watch mode ready - watching ${totalFiles} files`);
-			consola.info(`💡 Press ${colors.cyan("Ctrl+C")} to stop watching`);
-			resolve$1();
-		});
-	});
-	return () => {
-		if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
-		return watcher.close();
-	};
-}
-/**
-* Handle file change events
-*/
-function handleFileChange(watchCtx, filePath, changeType) {
-	const { config, ctx } = watchCtx;
-	const watchOptions = config.watch || {};
-	const delay = watchOptions.delay ?? 100;
-	const relativePath = relative(ctx.pkgDir, join(ctx.pkgDir, filePath));
-	const formattedPath = fmtPath(relativePath);
-	const changeIcon = changeType === "changed" ? "📝" : changeType === "added" ? "➕" : "➖";
-	consola.info(`${changeIcon} ${colors.cyan(formattedPath)} ${changeType}`);
-	if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
-	watchCtx.pendingRebuild = true;
-	watchCtx.rebuildTimer = setTimeout(() => {
-		triggerRebuild(watchCtx);
-	}, delay);
-}
+//#region src/build.ts
 /**
-* Trigger a rebuild
+* Normalize tsup-style config to entries-based config
 */
-async function triggerRebuild(watchCtx) {
-	const { config, buildFn } = watchCtx;
-	if (watchCtx.isBuilding) return;
-	if (!watchCtx.pendingRebuild) return;
-	watchCtx.isBuilding = true;
-	watchCtx.pendingRebuild = false;
-	try {
-		consola.info(`🔄 Rebuilding...`);
-		const start = Date.now();
-		const buildConfig = {
+function normalizeTsupConfig(config) {
+	if (config.entries && config.entries.length > 0) return config;
+	if (config.entry) {
+		const entry = {
+			type: "bundle",
+			entry: config.entry,
+			format: config.format,
+			outDir: config.outDir,
+			platform: config.platform,
+			target: config.target,
+			globalName: config.name,
+			minify: config.minify,
+			dts: config.dts,
+			dtsOnly: config.dtsOnly,
+			splitting: config.splitting,
+			treeshake: config.treeshake,
+			sourcemap: config.sourcemap,
+			external: config.external,
+			noExternal: config.noExternal,
+			env: config.env,
+			alias: config.alias,
+			banner: config.banner,
+			footer: config.footer,
+			shims: config.shims,
+			rolldown: config.rolldown
+		};
+		return {
 			...config,
-			watch: {
-				...config.watch,
-				enabled: false
-			}
+			entries: [entry]
 		};
-		await buildFn(buildConfig);
-		const duration = Date.now() - start;
-		consola.success(`✅ Rebuild completed in ${duration}ms`);
-	} catch (error) {
-		consola.error("❌ Rebuild failed:");
-		if (error instanceof Error) {
-			consola.error(`   ${error.message}`);
-			if (process.env.DEBUG && error.stack) consola.debug(error.stack);
-		} else consola.error(`   ${String(error)}`);
-		consola.info("👀 Still watching for changes...");
-	} finally {
-		watchCtx.isBuilding = false;
-		if (watchCtx.pendingRebuild) setTimeout(() => triggerRebuild(watchCtx), watchCtx.config.watch?.delay ?? 100);
-	}
-}
-/**
-* Get patterns for files to watch
-*/
-async function getWatchPatterns(config, ctx, watchOptions) {
-	if (watchOptions.include && watchOptions.include.length > 0) return watchOptions.include;
-	const patterns = [];
-	for (const entry of config.entries || []) if (typeof entry === "string") {
-		const [input] = entry.split(":");
-		if (input.endsWith("/")) patterns.push(`${input}**/*`);
-		else {
-			const inputs = input.split(",");
-			for (const inputFile of inputs) {
-				patterns.push(inputFile);
-				const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
-				if (dir) patterns.push(`${dir}/**/*`);
-			}
-		}
-	} else if (entry.type === "transform") patterns.push(`${entry.input}/**/*`);
-	else {
-		const inputs = Array.isArray(entry.input) ? entry.input : [entry.input];
-		for (const inputFile of inputs) {
-			patterns.push(inputFile);
-			const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
-			if (dir) patterns.push(`${dir}/**/*`);
-		}
 	}
-	if (patterns.length === 0) patterns.push("src/**/*", "*.ts", "*.js", "*.mjs", "*.json");
-	return [...new Set(patterns)];
-}
-/**
-* Get patterns for files to ignore
-*/
-function getIgnorePatterns(config, watchOptions) {
-	const defaultIgnores = [
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/build/**",
-		"**/coverage/**",
-		"**/.git/**",
-		"**/.DS_Store",
-		"**/Thumbs.db",
-		"**/*.log",
-		"**/tmp/**",
-		"**/temp/**"
-	];
-	const allIgnores = [...defaultIgnores];
-	if (watchOptions.exclude && watchOptions.exclude.length > 0) allIgnores.push(...watchOptions.exclude);
-	if (config.ignoreWatch && config.ignoreWatch.length > 0) allIgnores.push(...normalizeIgnorePatterns(config.ignoreWatch));
-	return allIgnores;
+	return config;
 }
-
-//#endregion
-//#region src/build.ts
 /**
 * Build dist/ from src/
 */
@@ -2178,7 +1938,6 @@ async function build(config) {
 		pkg,
 		pkgDir
 	};
-	if (config.workspace) return buildWorkspace(config, pkgDir);
 	let finalConfig = config;
 	if (config.fromVite) {
 		logger.verbose("Loading configuration from Vite config file");
@@ -2188,18 +1947,11 @@ async function build(config) {
 			...config
 		};
 	}
+	finalConfig = normalizeTsupConfig(finalConfig);
 	if (finalConfig.watch?.enabled) {
 		logger.info(`👀 Starting watch mode for \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
-		await performBuild(finalConfig, ctx, startTime);
-		const stopWatch = await startWatch(finalConfig, ctx, build);
-		const cleanup = () => {
-			consola.info("🛑 Stopping watch mode...");
-			stopWatch();
-			process.exit(0);
-		};
-		process.on("SIGINT", cleanup);
-		process.on("SIGTERM", cleanup);
-		return new Promise(() => {});
+		await performWatchBuild(finalConfig, ctx, startTime);
+		return;
 	}
 	logger.info(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
 	await performBuild(finalConfig, ctx, startTime);
@@ -2225,10 +1977,17 @@ async function performBuild(config, ctx, startTime) {
 				outDir
 			};
 		} else entry = rawEntry;
-		if (!entry.input) throw new Error(`Build entry missing \`input\`: ${JSON.stringify(entry, null, 2)}`);
+		const hasInput = entry.type === "transform" ? !!entry.input : !!(entry.input || entry.entry);
+		if (!hasInput) throw new Error(`Build entry missing \`input\` or \`entry\`: ${JSON.stringify(entry, null, 2)}`);
 		entry = { ...entry };
 		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
-		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, ctx.pkgDir)) : normalizePath(entry.input, ctx.pkgDir);
+		const entryInput = entry.input || entry.entry;
+		if (entryInput) if (typeof entryInput === "object" && !Array.isArray(entryInput)) {
+			const normalizedInput = {};
+			for (const [key, value] of Object.entries(entryInput)) normalizedInput[key] = normalizePath(value, ctx.pkgDir);
+			entry.input = normalizedInput;
+		} else if (Array.isArray(entryInput)) entry.input = entryInput.map((p) => normalizePath(p, ctx.pkgDir));
+		else entry.input = normalizePath(entryInput, ctx.pkgDir);
 		return entry;
 	});
 	await hooks.entries?.(entries, ctx);
@@ -2249,56 +2008,10 @@ async function performBuild(config, ctx, startTime) {
 function normalizePath(path, resolveFrom) {
 	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
 }
-/**
-* Build workspace packages
-*/
-async function buildWorkspace(config, workspaceRoot) {
-	logger.info("🏢 Building workspace packages...");
-	const workspaceConfig = await loadWorkspaceConfig(workspaceRoot);
-	if (!workspaceConfig) throw new Error("No workspace configuration found");
-	const allPackages = await discoverWorkspacePackages(workspaceRoot, workspaceConfig.packages);
-	if (allPackages.length === 0) {
-		logger.warn("No packages found in workspace");
-		return;
-	}
-	const filteredPackages = filterWorkspacePackages(allPackages, config.filter || config.workspace?.filter, config.workspace?.exclude);
-	if (filteredPackages.length === 0) {
-		logger.warn("No packages match the filter criteria");
-		return;
-	}
-	logger.info(`Building ${filteredPackages.length} packages`);
-	const buildPackage = async (pkg) => {
-		logger.info(`📦 Building ${pkg.name}...`);
-		try {
-			const packageConfig = {
-				...config,
-				cwd: pkg.path,
-				workspace: void 0
-			};
-			await build(packageConfig);
-			if (config.exports?.enabled) {
-				const exportsConfig = {
-					enabled: true,
-					...config.exports
-				};
-				const exports = await generatePackageExports(pkg.path, packageConfig, exportsConfig);
-				if (config.exports.autoUpdate) {
-					await updatePackageJsonExports(pkg.path, exports);
-					logger.info(`Updated exports for ${pkg.name}`);
-				}
-			}
-			logger.success(`Built ${pkg.name}`);
-		} catch (error) {
-			logger.error(`Failed to build ${pkg.name}:`, error);
-			throw error;
-		}
-	};
-	await buildWorkspacePackages(filteredPackages, buildPackage);
-	logger.success(`Successfully built ${filteredPackages.length} packages`);
-}
-function readJSON(specifier) {
-	return import(specifier, { with: { type: "json" } }).then((r) => r.default);
+async function readJSON(specifier) {
+	const module = await import(specifier, { with: { type: "json" } });
+	return module.default;
 }
 
 //#endregion
-export { build };
+export { SHEBANG_RE, build, hasShebang, makeExecutable, nodeProtocolPlugin, performBuild, shebangPlugin };