robuild 0.0.18 → 0.0.20

package/dist/_chunks/{build-omZA_xD-.mjs → build-ZNO1BJMb.mjs}

@@ -1,26 +1,115 @@
-import { RobuildPluginManager } from "./plugin-manager-w5yRGJRn.mjs";
+import { t as RobuildPluginManager } from "./plugin-manager-CwMXjVtp.mjs";
 import { builtinModules } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { colors } from "consola/utils";
 import prettyBytes from "pretty-bytes";
-import { cp, mkdir, readFile, readdir, symlink, writeFile } from "node:fs/promises";
-import { consola } from "consola";
+import { cp, mkdir, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import { resolveModulePath } from "exsolve";
 import { parseSync } from "oxc-parser";
 import { rolldown, watch } from "rolldown";
 import { dts } from "rolldown-plugin-dts";
 import { existsSync, promises, readdirSync, statSync } from "node:fs";
-import { glob } from "glob";
-import { createHash } from "node:crypto";
+import { consola } from "consola";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { gzipSync } from "node:zlib";
 import { minify } from "oxc-minify";
+import { glob } from "glob";
+import { createHash } from "node:crypto";
 import MagicString from "magic-string";
 import { transform } from "oxc-transform";
 import { glob as glob$1 } from "tinyglobby";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 
+//#region src/features/logger.ts
+/**
+* Logger instance with configurable log level
+*/
+var Logger = class {
+	level = "info";
+	warningCount = 0;
+	errorCount = 0;
+	constructor(level = "info") {
+		this.level = level;
+		this.updateConsolaLevel();
+	}
+	setLevel(level) {
+		this.level = level;
+		this.updateConsolaLevel();
+	}
+	updateConsolaLevel() {
+		consola.level = {
+			silent: 0,
+			error: 1,
+			warn: 2,
+			info: 3,
+			verbose: 4
+		}[this.level];
+	}
+	silent(message, ...args) {
+		consola.log(message, ...args);
+	}
+	error(message, ...args) {
+		this.errorCount++;
+		consola.error(message, ...args);
+	}
+	warn(message, ...args) {
+		this.warningCount++;
+		consola.warn(message, ...args);
+	}
+	info(message, ...args) {
+		consola.info(message, ...args);
+	}
+	verbose(message, ...args) {
+		if (this.level === "verbose") consola.debug(message, ...args);
+	}
+	success(message, ...args) {
+		consola.success(message, ...args);
+	}
+	log(message, ...args) {
+		consola.log(message, ...args);
+	}
+	/**
+	* Debug output - only visible with INSPECT_BUILD env var
+	*/
+	debug(message, ...args) {
+		if (process.env.INSPECT_BUILD) consola.log(message, ...args);
+	}
+	getWarningCount() {
+		return this.warningCount;
+	}
+	getErrorCount() {
+		return this.errorCount;
+	}
+	resetCounts() {
+		this.warningCount = 0;
+		this.errorCount = 0;
+	}
+	shouldFailOnWarnings(failOnWarn) {
+		return failOnWarn && this.warningCount > 0;
+	}
+};
+const logger = new Logger();
+/**
+* Configure global logger
+*/
+function configureLogger(level) {
+	logger.setLevel(level);
+}
+/**
+* Reset warning and error counts
+*/
+function resetLogCounts() {
+	logger.resetCounts();
+}
+/**
+* Check if build should fail due to warnings
+*/
+function shouldFailOnWarnings(failOnWarn) {
+	return logger.shouldFailOnWarnings(failOnWarn);
+}
+
+//#endregion
 //#region src/features/advanced-build.ts
 /**
 * Create skip node_modules plugin
@@ -52,9 +141,7 @@ function createSkipNodeModulesPlugin(options) {
 * Unbundle mode: preserve file structure without bundling
 */
 async function unbundleTransform(ctx, entry) {
-	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);
+	await processDirectoryUnbundled(isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input), join(ctx.pkgDir, entry.outDir || "dist"), entry);
 }
 /**
 * Process directory in unbundle mode
@@ -87,14 +174,13 @@ async function processFileUnbundled(inputPath, outputPath, entry) {
 		".cts"
 	].includes(ext)) return;
 	try {
-		const content = await readFile(inputPath, "utf-8");
-		const transformedContent = transformImportsForUnbundle(content, inputPath, entry);
+		const transformedContent = transformImportsForUnbundle(await readFile(inputPath, "utf-8"), inputPath, entry);
 		const outputExt = getUnbundleOutputExtension(ext, entry);
 		const finalOutputPath = outputPath.replace(ext, outputExt);
 		await mkdir(dirname(finalOutputPath), { recursive: true });
 		await writeFile(finalOutputPath, transformedContent, "utf-8");
 	} catch (error) {
-		console.warn(`Failed to process file ${inputPath}:`, error);
+		logger.warn(`Failed to process file ${inputPath}:`, error);
 	}
 }
 /**
@@ -159,10 +245,9 @@ function getUnbundleOutputExtension(inputExt, entry) {
 * Resolve banner/footer addon for specific format
 */
 function resolveChunkAddon(addon, format) {
-	if (!addon) return void 0;
+	if (!addon) return;
 	if (typeof addon === "string") return addon;
-	const formatKey = format === "es" ? "js" : format;
-	return addon[formatKey] || addon.js;
+	return addon[format === "es" ? "js" : format] || addon.js;
 }
 /**
 * Add banner to content
@@ -188,6 +273,136 @@ function addBannerFooter(content, banner, footer) {
 	return result;
 }
 
+//#endregion
+//#region src/utils.ts
+/**
+* Normalize a path to an absolute path.
+* Handles string paths, URL objects, and undefined values.
+*
+* @param path - The path to normalize (string, URL, or undefined)
+* @param resolveFrom - The base directory to resolve relative paths from
+* @returns The normalized absolute path
+*/
+function normalizePath(path, resolveFrom) {
+	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
+}
+function fmtPath(path) {
+	return resolve(path).replace(process.cwd(), ".");
+}
+function analyzeDir(dir) {
+	if (Array.isArray(dir)) {
+		let totalSize = 0;
+		let totalFiles = 0;
+		for (const d of dir) {
+			const { size, files } = analyzeDir(d);
+			totalSize += size;
+			totalFiles += files;
+		}
+		return {
+			size: totalSize,
+			files: totalFiles
+		};
+	}
+	let totalSize = 0;
+	try {
+		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
+		};
+	} catch (error) {
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") return {
+			size: 0,
+			files: 0
+		};
+		throw error;
+	}
+}
+async function distSize(dir, entry) {
+	const { output } = await (await rolldown({
+		input: join(dir, entry),
+		plugins: [],
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir)
+	})).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 { output } = await (await rolldown({
+		input: "#entry",
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir),
+		plugins: [{
+			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)}";`;
+			}
+		}]
+	})).generate({ inlineDynamicImports: true });
+	if (process.env.INSPECT_BUILD) {
+		logger.debug("---------[side effects]---------");
+		logger.debug(entry);
+		logger.debug(output[0].code);
+		logger.debug("-------------------------------");
+	}
+	return Buffer.byteLength(output[0].code.trim());
+}
+
+//#endregion
+//#region src/features/clean.ts
+/**
+* Clean output directory or specific paths.
+* Used by both bundle and transform builders.
+*
+* @param projectRoot - The project root directory
+* @param outDir - The output directory to clean
+* @param cleanPaths - true to clean outDir, or array of specific paths to clean
+*/
+async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
+	if (!cleanPaths) return;
+	if (cleanPaths === true) {
+		if (existsSync(outDir)) {
+			logger.log(colors.dim(`Cleaning ${fmtPath(outDir)}`));
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
+		const fullPath = resolve(projectRoot, path);
+		if (existsSync(fullPath)) {
+			logger.log(colors.dim(`Cleaning ${fmtPath(fullPath)}`));
+			await rm(fullPath, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+}
+
 //#endregion
 //#region src/features/copy.ts
 /**
@@ -195,7 +410,7 @@ function addBannerFooter(content, banner, footer) {
 */
 async function copyFiles(cwd, outDir, copyOptions) {
 	if (!copyOptions || copyOptions.length === 0) return;
-	consola.debug("📁 Copying files...");
+	logger.verbose("Copying files...");
 	await Promise.all(copyOptions.map(async (entry) => {
 		const from = typeof entry === "string" ? entry : entry.from;
 		const to = typeof entry === "string" ? resolve(outDir, basename(from)) : resolve(cwd, entry.to);
@@ -205,12 +420,231 @@ async function copyFiles(cwd, outDir, copyOptions) {
 				recursive: true,
 				force: true
 			});
-			consola.debug(`  ${from} → ${to}`);
+			logger.verbose(`  ${from} → ${to}`);
 		} catch (error) {
-			consola.warn(`Failed to copy ${from} to ${to}:`, error);
+			logger.warn(`Failed to copy ${from} to ${to}:`, error);
 		}
 	}));
-	consola.debug("✅ Files copied successfully");
+	logger.verbose("Files copied successfully");
+}
+
+//#endregion
+//#region src/features/entry-resolver.ts
+/**
+* Parse a string entry format like "src/index.ts:dist" or "src/:dist"
+*
+* @param rawEntry - The raw string entry
+* @returns Parsed entry object
+*/
+function parseEntryString(rawEntry) {
+	const [input, outDir] = rawEntry.split(":");
+	if (input.endsWith("/")) return {
+		type: "transform",
+		input,
+		outDir: outDir || "dist"
+	};
+	return {
+		type: "bundle",
+		input: input.includes(",") ? input.split(",") : input,
+		outDir: outDir || "dist"
+	};
+}
+/**
+* Normalize entry input paths to absolute paths.
+* Handles string, array, and object (named entries) formats.
+*
+* @param entryInput - The entry input (string, array, or object)
+* @param pkgDir - The package directory to resolve paths from
+* @returns Normalized input
+*/
+function normalizeEntryInput(entryInput, pkgDir) {
+	if (typeof entryInput === "object" && !Array.isArray(entryInput)) {
+		const normalizedInput = {};
+		for (const [key, value] of Object.entries(entryInput)) normalizedInput[key] = normalizePath(value, pkgDir);
+		return normalizedInput;
+	}
+	if (Array.isArray(entryInput)) return entryInput.map((p) => normalizePath(p, pkgDir));
+	return normalizePath(entryInput, pkgDir);
+}
+/**
+* Get the entry input from a BundleEntry, supporting both 'input' and 'entry' fields.
+* This provides tsup compatibility.
+*
+* @param entry - The bundle entry
+* @returns The entry input or undefined
+*/
+function getBundleEntryInput(entry) {
+	return entry.input || entry.entry;
+}
+/**
+* Check if an entry has valid input.
+*
+* @param entry - The entry to check
+* @returns true if the entry has valid input
+*/
+function hasValidInput(entry) {
+	if (entry.type === "transform") return !!entry.input;
+	return !!getBundleEntryInput(entry);
+}
+
+//#endregion
+//#region src/features/extensions.ts
+/**
+* Get file extension for a given format (with leading dot).
+* This is the unified function used by bundle, watch, and transform modes.
+*
+* @param format - The module format (es, cjs, iife, umd, etc.)
+* @param platform - The target platform
+* @param fixedExtension - Whether to force .cjs/.mjs extensions
+* @returns The file extension with leading dot (e.g., '.mjs', '.cjs', '.js')
+*/
+function getFormatExtension(format, platform = "node", fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" || format === "commonjs" ? ".cjs" : ".mjs";
+	switch (format) {
+		case "es":
+		case "esm":
+		case "module": return ".mjs";
+		case "cjs":
+		case "commonjs": return platform === "node" ? ".cjs" : ".js";
+		case "iife":
+		case "umd": return ".js";
+		default: return ".js";
+	}
+}
+/**
+* Resolve JavaScript output extension (without leading dot).
+* @deprecated Use getFormatExtension() instead for consistency
+*/
+function resolveJsOutputExtension(format, platform = "node", fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" ? "cjs" : "mjs";
+	switch (format) {
+		case "es": return platform === "browser" ? "js" : "mjs";
+		case "cjs": return platform === "browser" ? "js" : "cjs";
+		case "iife":
+		case "umd": return "js";
+		default: return "js";
+	}
+}
+/**
+* Resolve DTS output extension
+*/
+function resolveDtsOutputExtension(format, fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" ? "d.cts" : "d.mts";
+	switch (format) {
+		case "es": return "d.mts";
+		case "cjs": return "d.cts";
+		default: return "d.ts";
+	}
+}
+/**
+* Apply custom output extensions
+*/
+function applyOutExtensions(format, outExtensions) {
+	const defaultJs = resolveJsOutputExtension(format);
+	const defaultDts = resolveDtsOutputExtension(format);
+	if (!outExtensions) return {
+		js: defaultJs,
+		dts: defaultDts
+	};
+	const custom = outExtensions(format);
+	return {
+		js: custom.js || defaultJs,
+		dts: custom.dts || defaultDts
+	};
+}
+/**
+* Create filename with proper extension
+*/
+function createFilename(basename, format, isDts = false, options = {}) {
+	const { platform, fixedExtension, outExtensions } = options;
+	if (outExtensions) {
+		const extensions = applyOutExtensions(format, outExtensions);
+		return `${basename}.${isDts ? extensions.dts : extensions.js}`;
+	}
+	if (isDts) return `${basename}.${resolveDtsOutputExtension(format, fixedExtension)}`;
+	return `${basename}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
+}
+
+//#endregion
+//#region src/features/external.ts
+/**
+* Build external dependencies list from package.json dependencies and peerDependencies.
+* This is the shared logic used by both bundle and watch modes.
+*/
+function buildExternalDeps(ctx) {
+	return [
+		...builtinModules,
+		...builtinModules.map((m) => `node:${m}`),
+		...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, new RegExp(`^${p}/`)])
+	];
+}
+/**
+* Escape special regex characters in a string
+*/
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Apply noExternal configuration to filter out dependencies that should be bundled.
+* Supports both function and array forms.
+*/
+function applyNoExternal(externalDeps, noExternal, ctx) {
+	if (!noExternal) return externalDeps;
+	if (typeof noExternal === "function") {
+		const predicate = noExternal;
+		const depNames = [...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})];
+		const excludedNames = /* @__PURE__ */ new Set();
+		for (const name of depNames) try {
+			if (predicate(name)) excludedNames.add(name);
+		} catch {}
+		return externalDeps.filter((dep) => {
+			if (typeof dep === "string") return !excludedNames.has(dep);
+			if (dep instanceof RegExp) {
+				for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
+				return true;
+			}
+			return true;
+		});
+	}
+	if (Array.isArray(noExternal)) {
+		const rules = noExternal;
+		return externalDeps.filter((dep) => {
+			for (const rule of rules) if (typeof rule === "string") {
+				if (typeof dep === "string") {
+					if (dep === rule) return false;
+				} else if (dep instanceof RegExp) {
+					if (dep.source.startsWith(`^${escapeRegExp(rule)}/`)) return false;
+				}
+			} else if (rule instanceof RegExp) {
+				if (typeof dep === "string") {
+					if (rule.test(dep)) return false;
+				} else if (dep instanceof RegExp) {
+					if (dep.source === rule.source && dep.flags === rule.flags) return false;
+				}
+			}
+			return true;
+		});
+	}
+	return externalDeps;
+}
+/**
+* Add custom external dependencies to the list.
+* Only handles array form; function form is handled separately.
+*/
+function addCustomExternal(externalDeps, external) {
+	if (external && typeof external !== "function") return [...externalDeps, ...external];
+	return externalDeps;
+}
+/**
+* Build the complete external configuration for rolldown.
+* Returns either a function (if entry.external is a function) or the processed array.
+*/
+function resolveExternalConfig(ctx, options) {
+	let externalDeps = buildExternalDeps(ctx);
+	externalDeps = applyNoExternal(externalDeps, options.noExternal, ctx);
+	externalDeps = addCustomExternal(externalDeps, options.external);
+	if (typeof options.external === "function") return options.external;
+	return externalDeps;
 }
 
 //#endregion
@@ -235,7 +669,7 @@ function createGlobImportPlugin(options = {}) {
 				if (optionsStr) try {
 					globOptions = parseGlobOptions(optionsStr);
 				} catch {
-					console.warn("Failed to parse glob options:", optionsStr);
+					logger.warn("Failed to parse glob options:", optionsStr);
 				}
 				const isEager = globOptions.eager ?? eager;
 				const isAsUrls = globOptions.as === "url" || asUrls;
@@ -243,7 +677,7 @@ function createGlobImportPlugin(options = {}) {
 					const replacement = await generateGlobImport(pattern, id, isEager, isAsUrls, patterns);
 					transformedCode = transformedCode.replace(fullMatch, replacement);
 				} catch (error) {
-					console.error(`Failed to process glob import ${pattern}:`, error);
+					logger.error(`Failed to process glob import ${pattern}:`, error);
 				}
 			}
 			return hasGlobImports ? transformedCode : null;
@@ -258,8 +692,7 @@ async function generateGlobImport(pattern, importer, eager, asUrls, allowedPatte
 	if (!isPatternAllowed(pattern, allowedPatterns)) throw new Error(`Glob pattern "${pattern}" is not allowed`);
 	let files = [];
 	try {
-		const absolutePattern = resolve(importerDir, pattern);
-		files = await glob(absolutePattern, { ignore: ["**/node_modules/**", "**/.git/**"] });
+		files = await glob(resolve(importerDir, pattern), { ignore: ["**/node_modules/**", "**/.git/**"] });
 	} catch {
 		if (pattern.includes("*.js")) files = [resolve(importerDir, pattern.replace("*", "module1")), resolve(importerDir, pattern.replace("*", "module2"))];
 	}
@@ -336,9 +769,7 @@ function addHashToFilename(filename, content, hashLength = 8) {
 	const hash = generateContentHash(content, hashLength);
 	const dotIndex = filename.lastIndexOf(".");
 	if (dotIndex === -1) return `${filename}-${hash}`;
-	const name = filename.slice(0, dotIndex);
-	const ext = filename.slice(dotIndex);
-	return `${name}-${hash}${ext}`;
+	return `${filename.slice(0, dotIndex)}-${hash}${filename.slice(dotIndex)}`;
 }
 /**
 * Check if filename already has hash
@@ -402,15 +833,11 @@ if (typeof exports === 'undefined') {
 */
 function detectShimNeeds(code) {
 	const cleanCode = removeCommentsAndStrings(code);
-	const needsDirname = /\b__dirname\b/.test(cleanCode) || /\b__filename\b/.test(cleanCode);
-	const needsRequire = /\brequire\s*\(/.test(cleanCode);
-	const needsExports = /\bmodule\.exports\b/.test(cleanCode) || /\bexports\.\w+/.test(cleanCode);
-	const needsEnv = /\bprocess\.env\b/.test(cleanCode);
 	return {
-		needsDirname,
-		needsRequire,
-		needsExports,
-		needsEnv
+		needsDirname: /\b__dirname\b/.test(cleanCode) || /\b__filename\b/.test(cleanCode),
+		needsRequire: /\brequire\s*\(/.test(cleanCode),
+		needsExports: /\bmodule\.exports\b/.test(cleanCode) || /\bexports\.\w+/.test(cleanCode),
+		needsEnv: /\bprocess\.env\b/.test(cleanCode)
 	};
 }
 /**
@@ -438,8 +865,7 @@ const require = createRequire(import.meta.url)
 * Transform code to use shims
 */
 function transformWithShims(code, config) {
-	const needs = detectShimNeeds(code);
-	const shims = generateShims(config, needs);
+	const shims = generateShims(config, detectShimNeeds(code));
 	if (!shims) return code;
 	return `${shims}\n${code}`;
 }
@@ -552,191 +978,55 @@ function processNodeProtocol(id, nodeProtocol) {
 */
 function transformNodeProtocol(code, nodeProtocol) {
 	if (!nodeProtocol) return code;
-	const importRegex = /(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g;
-	return code.replace(importRegex, (match, moduleId) => {
+	return code.replace(/(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g, (match, moduleId) => {
 		const processedId = processNodeProtocol(moduleId, nodeProtocol);
-		return match.replace(moduleId, processedId);
-	});
-}
-
-//#endregion
-//#region src/plugins/node-protocol.ts
-/**
-* Rolldown plugin for Node.js protocol handling
-*/
-function nodeProtocolPlugin(nodeProtocol) {
-	if (!nodeProtocol) return { name: "node-protocol-noop" };
-	return {
-		name: "node-protocol",
-		renderChunk(code) {
-			return {
-				code: transformNodeProtocol(code, nodeProtocol),
-				map: null
-			};
-		}
-	};
-}
-
-//#endregion
-//#region src/plugins/shebang.ts
-const SHEBANG_RE = /^#![^\n]*/;
-function shebangPlugin() {
-	return {
-		name: "robuild-shebang",
-		async writeBundle(options, bundle) {
-			for (const [fileName, output] of Object.entries(bundle)) {
-				if (output.type !== "chunk") continue;
-				if (hasShebang(output.code)) {
-					const outFile = resolve(options.dir, fileName);
-					await makeExecutable(outFile);
-				}
-			}
-		}
-	};
-}
-function hasShebang(code) {
-	return SHEBANG_RE.test(code);
-}
-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 } = analyzeDir(d);
-			totalSize$1 += size;
-			totalFiles += files;
-		}
-		return {
-			size: totalSize$1,
-			files: totalFiles
-		};
-	}
-	let totalSize = 0;
-	try {
-		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
-		};
-	} catch (error) {
-		if (error.code === "ENOENT" || error.code === "ENOTDIR") return {
-			size: 0,
-			files: 0
-		};
-		throw error;
-	}
-}
-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]
+		return match.replace(moduleId, processedId);
 	});
-	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
-/**
-* Get file extension for format
-*/
-function getFormatExtension(format, platform, fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" ? ".cjs" : ".mjs";
-	switch (format) {
-		case "es":
-		case "esm":
-		case "module": return ".mjs";
-		case "cjs":
-		case "commonjs": return platform === "node" ? ".cjs" : ".js";
-		case "iife":
-		case "umd": return ".js";
-		default: return ".js";
-	}
-}
+//#region src/plugins/node-protocol.ts
 /**
-* Clean output directory
+* Rolldown plugin for Node.js protocol handling
 */
-async function cleanOutputDir$1(projectRoot, outDir, cleanPaths) {
-	if (!cleanPaths) return;
-	const { rm } = await import("node:fs/promises");
-	const { existsSync: existsSync$1 } = await import("node:fs");
-	if (cleanPaths === true) {
-		if (existsSync$1(outDir)) {
-			consola.log(`🧻 Cleaning up ${fmtPath(outDir)}`);
-			await rm(outDir, {
-				recursive: true,
-				force: true
-			});
+function nodeProtocolPlugin(nodeProtocol) {
+	if (!nodeProtocol) return { name: "node-protocol-noop" };
+	return {
+		name: "node-protocol",
+		renderChunk(code) {
+			return {
+				code: transformNodeProtocol(code, nodeProtocol),
+				map: null
+			};
 		}
-	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
-		const fullPath = resolve(projectRoot, path);
-		if (existsSync$1(fullPath)) {
-			consola.log(`🧻 Cleaning up ${fmtPath(fullPath)}`);
-			await rm(fullPath, {
-				recursive: true,
-				force: true
-			});
+	};
+}
+
+//#endregion
+//#region src/plugins/shebang.ts
+const SHEBANG_RE = /^#![^\n]*/;
+function shebangPlugin() {
+	return {
+		name: "robuild-shebang",
+		async writeBundle(options, bundle) {
+			for (const [fileName, output] of Object.entries(bundle)) {
+				if (output.type !== "chunk") continue;
+				if (hasShebang(output.code)) await makeExecutable(resolve(options.dir, fileName));
+			}
 		}
-	}
+	};
 }
+function hasShebang(code) {
+	return SHEBANG_RE.test(code);
+}
+async function makeExecutable(filePath) {
+	await promises.chmod(filePath, 493).catch(() => {});
+}
+
+//#endregion
+//#region src/builders/bundle.ts
 async function rolldownBuild(ctx, entry, hooks, config) {
-	const entryInput = entry.input || entry.entry;
+	const entryInput = getBundleEntryInput(entry);
 	if (!entryInput) throw new Error("Entry input is required");
 	const inputs = normalizeBundleInputs(entryInput, ctx);
 	const pluginManager = new RobuildPluginManager(config || {}, entry, ctx.pkgDir);
@@ -754,20 +1044,18 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		outDir: fullOutDir
 	});
 	await pluginManager.executeRobuildBuildStart();
-	await cleanOutputDir$1(ctx.pkgDir, fullOutDir, entry.clean ?? true);
+	await cleanOutputDir(ctx.pkgDir, fullOutDir, entry.clean ?? true);
 	if (entry.dtsOnly) {
-		consola.info("Running in dtsOnly mode - only generating declaration files");
+		logger.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`);
 			await mkdir(dirname(distPath), { recursive: true });
-			consola.log(`${colors.magenta("[stub bundle] ")} ${colors.underline(fmtPath(distPath))}`);
+			logger.log(`${colors.cyan("Stub")}  ${colors.green(fmtPath(distPath))}`);
 			const srcContents = await readFile(srcPath, "utf8");
-			const parsed = parseSync(srcPath, srcContents);
-			const exportNames = parsed.module.staticExports.flatMap((e) => e.entries.map((e$1) => e$1.exportName.kind === "Default" ? "default" : e$1.exportName.name));
-			const hasDefaultExport = exportNames.includes("default");
+			const hasDefaultExport = parseSync(srcPath, srcContents).module.staticExports.flatMap((e) => e.entries.map((e) => e.exportName.kind === "Default" ? "default" : e.exportName.name)).includes("default");
 			const firstLine = srcContents.split("\n")[0];
 			const hasShebangLine = firstLine.startsWith("#!");
 			await writeFile(distPath, `${hasShebangLine ? `${firstLine}\n` : ""}export * from "${srcPath}";\n${hasDefaultExport ? `export { default } from "${srcPath}";\n` : ""}`, "utf8");
@@ -776,49 +1064,10 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		}
 		return;
 	}
-	let externalDeps = [
-		...builtinModules,
-		...builtinModules.map((m) => `node:${m}`),
-		...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, /* @__PURE__ */ new RegExp(`^${p}/`)])
-	];
-	if (entry.noExternal) {
-		const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		if (typeof entry.noExternal === "function") {
-			const predicate = entry.noExternal;
-			const depNames = [...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})];
-			const excludedNames = /* @__PURE__ */ new Set();
-			for (const name of depNames) try {
-				if (predicate(name)) excludedNames.add(name);
-			} catch {}
-			externalDeps = externalDeps.filter((dep) => {
-				if (typeof dep === "string") return !excludedNames.has(dep);
-				if (dep instanceof RegExp) {
-					for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
-					return true;
-				}
-				return true;
-			});
-		} else if (Array.isArray(entry.noExternal)) {
-			const rules = entry.noExternal;
-			externalDeps = externalDeps.filter((dep) => {
-				for (const rule of rules) if (typeof rule === "string") {
-					if (typeof dep === "string") {
-						if (dep === rule) return false;
-					} else if (dep instanceof RegExp) {
-						if (dep.source.startsWith(`^${escapeRegExp(rule)}/`)) return false;
-					}
-				} else if (rule instanceof RegExp) {
-					if (typeof dep === "string") {
-						if (rule.test(dep)) return false;
-					} else if (dep instanceof RegExp) {
-						if (dep.source === rule.source && dep.flags === rule.flags) return false;
-					}
-				}
-				return true;
-			});
-		}
-	}
-	if (entry.external) if (typeof entry.external === "function") {} else externalDeps.push(...entry.external);
+	const externalConfig = resolveExternalConfig(ctx, {
+		external: entry.external,
+		noExternal: entry.noExternal
+	});
 	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;
@@ -852,21 +1101,23 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 	}
 	rolldownPlugins.push(...pluginManager.getRolldownPlugins());
 	const moduleTypes = {};
-	if (entry.loaders) for (const [ext, config$1] of Object.entries(entry.loaders)) moduleTypes[ext] = config$1.loader;
+	if (entry.loaders) for (const [ext, config] of Object.entries(entry.loaders)) moduleTypes[ext] = config.loader;
 	const robuildGeneratedConfig = {
 		cwd: ctx.pkgDir,
 		input: inputs,
 		plugins: rolldownPlugins,
 		platform: platform === "node" ? "node" : "neutral",
-		external: typeof entry.external === "function" ? entry.external : externalDeps,
-		define: defineOptions,
+		external: externalConfig,
 		resolve: { alias: entry.alias || {} },
-		transform: { target },
+		transform: {
+			target,
+			define: defineOptions
+		},
 		...Object.keys(moduleTypes).length > 0 ? { moduleTypes } : {}
 	};
 	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 { output: userOutputConfig, plugins: userPlugins, ...userRolldownConfig } = entry.rolldown || {};
 	const baseRolldownConfig = {
 		...robuildGeneratedConfig,
 		...userRolldownConfig,
@@ -894,7 +1145,10 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			dir: formatOutDir,
 			format,
 			entryFileNames: entryFileName,
-			chunkFileNames: `_chunks/[name]-[hash]${extension}`,
+			chunkFileNames: (chunk) => {
+				if (chunk.name.endsWith(".d") || chunk.name.includes(".d.")) return `[name].mjs`;
+				return `_chunks/[name]-[hash]${extension}`;
+			},
 			minify: entry.minify,
 			name: entry.globalName,
 			banner: resolveChunkAddon(entry.banner, format),
@@ -938,9 +1192,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 				const { rename } = await import("node:fs/promises");
 				await rename(finalFilePath, hashedFilePath);
 				try {
-					const mapOld = `${finalFilePath}.map`;
-					const mapNew = `${hashedFilePath}.map`;
-					await rename(mapOld, mapNew);
+					await rename(`${finalFilePath}.map`, `${hashedFilePath}.map`);
 				} catch {}
 				finalFileName = hashedFileName;
 				finalFilePath = hashedFilePath;
@@ -958,29 +1210,26 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 	}
 	if (entry.copy) await copyFiles(ctx.pkgDir, fullOutDir, entry.copy);
 	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)})`),
-		o.exports.some((e) => e !== "default") ? colors.dim(`${colors.bold("Exports:")} ${o.exports.map((e) => e).join(", ")}`) : "",
-		o.deps.length > 0 ? colors.dim(`${colors.bold("Dependencies:")} ${o.deps.join(", ")}`) : ""
+	logger.log(`\n${allOutputEntries.map((o) => [
+		`${colors.cyan("Bundle")}  ${colors.green(fmtPath(filePathMap.get(o.name) || join(fullOutDir, o.name)))}`,
+		colors.dim(`         ${prettyBytes(o.size)} / minified: ${prettyBytes(o.minSize)} / gzip: ${prettyBytes(o.minGzipSize)}`),
+		o.exports.some((e) => e !== "default") ? colors.dim(`         Exports: ${o.exports.map((e) => e).join(", ")}`) : "",
+		o.deps.length > 0 ? colors.dim(`         Dependencies: ${o.deps.join(", ")}`) : ""
 	].filter(Boolean).join("\n")).join("\n\n")}`);
 }
 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;
-		}
+		for (const [name, src] of Object.entries(input)) inputs[name] = resolveModulePath(src, {
+			from: ctx.pkgDir,
+			extensions: [
+				".ts",
+				".js",
+				".mjs",
+				".cjs",
+				".json"
+			]
+		});
 		return inputs;
 	}
 	for (let src of Array.isArray(input) ? input : [input]) {
@@ -1004,122 +1253,39 @@ function normalizeBundleInputs(input, ctx) {
 	return inputs;
 }
 
-//#endregion
-//#region src/features/extensions.ts
-/**
-* Resolve JavaScript output extension
-*/
-function resolveJsOutputExtension(format, platform = "node", fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" ? "cjs" : "mjs";
-	switch (format) {
-		case "es": return platform === "browser" ? "js" : "mjs";
-		case "cjs": return platform === "browser" ? "js" : "cjs";
-		case "iife":
-		case "umd": return "js";
-		default: return "js";
-	}
-}
-/**
-* Resolve DTS output extension
-*/
-function resolveDtsOutputExtension(format, fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" ? "d.cts" : "d.mts";
-	switch (format) {
-		case "es": return "d.mts";
-		case "cjs": return "d.cts";
-		default: return "d.ts";
-	}
-}
-/**
-* Apply custom output extensions
-*/
-function applyOutExtensions(format, outExtensions) {
-	const defaultJs = resolveJsOutputExtension(format);
-	const defaultDts = resolveDtsOutputExtension(format);
-	if (!outExtensions) return {
-		js: defaultJs,
-		dts: defaultDts
-	};
-	const custom = outExtensions(format);
-	return {
-		js: custom.js || defaultJs,
-		dts: custom.dts || defaultDts
-	};
-}
-/**
-* Create filename with proper extension
-*/
-function createFilename(basename$1, format, isDts = false, options = {}) {
-	const { platform, fixedExtension, outExtensions } = options;
-	if (outExtensions) {
-		const extensions = applyOutExtensions(format, outExtensions);
-		return `${basename$1}.${isDts ? extensions.dts : extensions.js}`;
-	}
-	if (isDts) return `${basename$1}.${resolveDtsOutputExtension(format, fixedExtension)}`;
-	return `${basename$1}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
-}
-
 //#endregion
 //#region src/builders/transform.ts
 /**
-* Clean output directory for transform entries
-*/
-async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
-	if (!cleanPaths) return;
-	const { rm } = await import("node:fs/promises");
-	const { existsSync: existsSync$1 } = await import("node:fs");
-	if (cleanPaths === true) {
-		if (existsSync$1(outDir)) {
-			consola.log(`🧻 Cleaning up ${fmtPath(outDir)}`);
-			await rm(outDir, {
-				recursive: true,
-				force: true
-			});
-		}
-	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
-		const fullPath = resolve(projectRoot, path);
-		if (existsSync$1(fullPath)) {
-			consola.log(`🧻 Cleaning up ${fmtPath(fullPath)}`);
-			await rm(fullPath, {
-				recursive: true,
-				force: true
-			});
-		}
-	}
-}
-/**
 * Transform all .ts modules in a directory using oxc-transform.
 */
 async function transformDir(ctx, entry) {
 	if (entry.stub) {
-		consola.log(`${colors.magenta("[stub transform]   ")} ${colors.underline(`${fmtPath(entry.outDir)}/`)}`);
+		logger.log(`${colors.cyan("Stub")}  ${colors.green(`${fmtPath(entry.outDir)}/`)}`);
 		await symlink(entry.input, entry.outDir, "junction");
 		return;
 	}
 	if (entry.unbundle) {
-		consola.log(`${colors.magenta("[unbundle]         ")} ${colors.underline(`${fmtPath(entry.outDir)}/`)}`);
+		logger.log(`${colors.cyan("Unbundle")}  ${colors.green(`${fmtPath(entry.outDir)}/`)}`);
 		await unbundleTransform(ctx, entry);
 		return;
 	}
-	const fullOutDir = resolve(ctx.pkgDir, entry.outDir);
+	const fullOutDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
 	await cleanOutputDir(ctx.pkgDir, fullOutDir, entry.clean ?? true);
-	const { statSync: statSync$1 } = await import("node:fs");
+	const { statSync } = await import("node:fs");
 	let inputDir = entry.input;
 	try {
-		const stats = statSync$1(inputDir);
-		if (stats.isFile()) {
+		if (statSync(inputDir).isFile()) {
 			inputDir = dirname(inputDir);
-			consola.warn(`Transform input should be a directory, not a file. Using directory: ${fmtPath(inputDir)}`);
+			logger.warn(`Transform input should be a directory, not a file. Using directory: ${fmtPath(inputDir)}`);
 		}
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
-	const promises$1 = [];
+	const promises = [];
 	const files = await glob$1("**/*.*", { cwd: inputDir });
-	for await (const entryName of files) promises$1.push((async () => {
+	for await (const entryName of files) promises.push((async () => {
 		const entryPath = join(inputDir, entryName);
-		const ext = extname(entryPath);
-		switch (ext) {
+		switch (extname(entryPath)) {
 			case ".ts":
 			case ".tsx":
 			case ".jsx": {
@@ -1133,11 +1299,7 @@ async function transformDir(ctx, entry) {
 				let entryDistPath = join(entry.outDir, outputFileName);
 				await mkdir(dirname(entryDistPath), { recursive: true });
 				await writeFile(entryDistPath, transformed.code, "utf8");
-				if (entry.sourcemap && transformed.map) {
-					const mapPath = `${entryDistPath}.map`;
-					const mapContent = typeof transformed.map === "string" ? transformed.map : JSON.stringify(transformed.map);
-					await writeFile(mapPath, mapContent, "utf8");
-				}
+				if (entry.sourcemap && transformed.map) await writeFile(`${entryDistPath}.map`, typeof transformed.map === "string" ? transformed.map : JSON.stringify(transformed.map), "utf8");
 				if (entry.hash && !hasHash(entryDistPath)) {
 					const hashedPath = addHashToFilename(entryDistPath, transformed.code);
 					const { rename } = await import("node:fs/promises");
@@ -1151,8 +1313,7 @@ async function transformDir(ctx, entry) {
 						fixedExtension: entry.fixedExtension,
 						outExtensions: entry.outExtensions
 					});
-					const dtsPath = join(entry.outDir, dtsFileName);
-					await writeFile(dtsPath, transformed.declaration, "utf8");
+					await writeFile(join(entry.outDir, dtsFileName), transformed.declaration, "utf8");
 				}
 				return entryDistPath;
 			}
@@ -1166,9 +1327,9 @@ async function transformDir(ctx, entry) {
 			}
 		}
 	})());
-	const writtenFiles = await Promise.all(promises$1);
+	const writtenFiles = await Promise.all(promises);
 	if (entry.copy) await copyFiles(ctx.pkgDir, fullOutDir, entry.copy);
-	consola.log(`\n${colors.magenta("[transform] ")}${colors.underline(`${fmtPath(entry.outDir)}/`)}\n${writtenFiles.map((f) => colors.dim(fmtPath(f))).join("\n\n")}`);
+	logger.log(`\n${colors.cyan("Transform")}  ${colors.green(`${fmtPath(entry.outDir)}/`)} ${colors.dim(`(${writtenFiles.length} files)`)}`);
 }
 /**
 * Transform a .ts module using oxc-transform.
@@ -1176,9 +1337,8 @@ async function transformDir(ctx, entry) {
 async function transformModule(entryPath, entry) {
 	let sourceText = await readFile(entryPath, "utf8");
 	const ext = extname(entryPath);
-	const lang = ext === ".tsx" || ext === ".jsx" ? "tsx" : "ts";
 	const sourceOptions = {
-		lang,
+		lang: ext === ".tsx" || ext === ".jsx" ? "tsx" : "ts",
 		sourceType: "module"
 	};
 	const parsed = parseSync(entryPath, sourceText, { ...sourceOptions });
@@ -1254,90 +1414,6 @@ async function transformModule(entryPath, entry) {
 	return transformed;
 }
 
-//#endregion
-//#region src/features/logger.ts
-/**
-* Logger instance with configurable log level
-*/
-var Logger = class {
-	level = "info";
-	warningCount = 0;
-	errorCount = 0;
-	constructor(level = "info") {
-		this.level = level;
-		this.updateConsolaLevel();
-	}
-	setLevel(level) {
-		this.level = level;
-		this.updateConsolaLevel();
-	}
-	updateConsolaLevel() {
-		const levelMap = {
-			silent: 0,
-			error: 1,
-			warn: 2,
-			info: 3,
-			verbose: 4
-		};
-		consola.level = levelMap[this.level];
-	}
-	silent(message, ...args) {
-		console.log(message, ...args);
-	}
-	error(message, ...args) {
-		this.errorCount++;
-		consola.error(message, ...args);
-	}
-	warn(message, ...args) {
-		this.warningCount++;
-		consola.warn(message, ...args);
-	}
-	info(message, ...args) {
-		consola.info(message, ...args);
-	}
-	verbose(message, ...args) {
-		if (this.level === "verbose") consola.debug(message, ...args);
-	}
-	success(message, ...args) {
-		consola.success(message, ...args);
-	}
-	log(message, ...args) {
-		consola.log(message, ...args);
-	}
-	getWarningCount() {
-		return this.warningCount;
-	}
-	getErrorCount() {
-		return this.errorCount;
-	}
-	resetCounts() {
-		this.warningCount = 0;
-		this.errorCount = 0;
-	}
-	shouldFailOnWarnings(failOnWarn) {
-		return failOnWarn && this.warningCount > 0;
-	}
-};
-const logger = new Logger();
-/**
-* Configure global logger
-*/
-function configureLogger(level) {
-	logger.setLevel(level);
-}
-/**
-* Reset warning and error counts
-*/
-function resetLogCounts() {
-	logger.resetCounts();
-}
-/**
-* Check if build should fail due to warnings
-*/
-function shouldFailOnWarnings(failOnWarn) {
-	return logger.shouldFailOnWarnings(failOnWarn);
-}
-
 //#endregion
 //#region src/features/on-success.ts
 const execAsync = promisify(exec);
@@ -1404,8 +1480,7 @@ async function loadViteConfig(cwd) {
 	try {
 		logger.verbose(`Loading Vite config from: ${configPath}`);
 		const configModule = await import(configPath);
-		const viteConfig = configModule.default || configModule;
-		return convertViteConfig(viteConfig);
+		return convertViteConfig(configModule.default || configModule);
 	} catch (error) {
 		logger.error(`Failed to load Vite config from ${configPath}:`, error);
 		return {};
@@ -1468,7 +1543,7 @@ function convertFormats(formats) {
 */
 function convertTarget(target) {
 	if (!target) return void 0;
-	const targetMap = {
+	return {
 		es2015: "es2015",
 		es2016: "es2016",
 		es2017: "es2017",
@@ -1478,8 +1553,7 @@ function convertTarget(target) {
 		es2021: "es2021",
 		es2022: "es2022",
 		esnext: "esnext"
-	};
-	return targetMap[target] || void 0;
+	}[target] || void 0;
 }
 /**
 * Convert Vite external config to robuild external
@@ -1490,15 +1564,12 @@ function convertExternal(external) {
 
 //#endregion
 //#region src/watch.ts
-function normalizePath$1(path, resolveFrom) {
-	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
-}
 /**
 * Perform watch build using rolldown's built-in watch mode
 */
 async function performWatchBuild(config, ctx, startTime) {
-	const { performBuild: performBuild$1 } = await import("./build-S2eglIZn.mjs");
-	await performBuild$1(config, ctx, startTime);
+	const { performBuild } = await import("./build-B-lzI2ff.mjs");
+	await performBuild(config, ctx, startTime);
 	const bundleEntries = (config.entries || []).filter((entry) => {
 		if (typeof entry === "string") return !entry.endsWith("/");
 		return entry.type === "bundle";
@@ -1517,45 +1588,22 @@ async function performWatchBuild(config, ctx, startTime) {
 * The watch mode then monitors for file changes and triggers rebuilds.
 */
 async function startRolldownWatch(config, ctx, bundleEntries) {
-	logger.info("🚧 Using rolldown built-in watch mode...");
-	const { RobuildPluginManager: RobuildPluginManager$1 } = await import("./plugin-manager-WN1-NA--.mjs");
+	logger.info("Watching for changes...");
+	const { RobuildPluginManager } = await import("./plugin-manager-pCQvlo7q.mjs");
 	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;
-		const entryInput = entry.input || entry.entry;
+		const entry = typeof rawEntry === "string" ? parseEntryString(rawEntry) : rawEntry;
+		const entryInput = getBundleEntryInput(entry);
 		if (!entryInput) {
 			logger.warn("Skipping entry without input:", entry);
 			continue;
 		}
-		let normalizedInput;
-		if (typeof entryInput === "object" && !Array.isArray(entryInput)) {
-			const normalizedObj = {};
-			for (const [key, value] of Object.entries(entryInput)) normalizedObj[key] = normalizePath$1(value, ctx.pkgDir);
-			normalizedInput = normalizedObj;
-		} else if (Array.isArray(entryInput)) normalizedInput = entryInput.map((i) => normalizePath$1(i, ctx.pkgDir));
-		else normalizedInput = normalizePath$1(entryInput, ctx.pkgDir);
+		const normalizedInput = normalizeEntryInput(entryInput, ctx.pkgDir);
 		const target = entry.target || "es2022";
 		const platform = entry.platform || "node";
 		const format = entry.format || "es";
-		const getExtension = (fmt) => {
-			switch (fmt) {
-				case "es": return ".mjs";
-				case "cjs": return ".cjs";
-				case "iife":
-				case "umd": return ".js";
-				default: return ".mjs";
-			}
-		};
-		const extension = getExtension(Array.isArray(format) ? format[0] : format);
 		const rolldownFormat = Array.isArray(format) ? format[0] : format;
+		const extension = getFormatExtension(rolldownFormat, platform);
 		const formatMap = {
 			esm: "es",
 			cjs: "cjs",
@@ -1566,8 +1614,11 @@ async function startRolldownWatch(config, ctx, bundleEntries) {
 		if (Array.isArray(normalizedInput)) rolldownInput = normalizedInput[0];
 		else if (typeof normalizedInput === "object") rolldownInput = normalizedInput;
 		else rolldownInput = normalizedInput;
-		const pluginManager = new RobuildPluginManager$1(config, entry, ctx.pkgDir);
-		const rolldownPlugins = [...pluginManager.getRolldownPlugins(), ...entry.rolldown?.plugins || []];
+		const rolldownPlugins = [...new RobuildPluginManager(config, entry, ctx.pkgDir).getRolldownPlugins(), ...entry.rolldown?.plugins || []];
+		const externalConfig = resolveExternalConfig(ctx, {
+			external: entry.external,
+			noExternal: entry.noExternal
+		});
 		const watchConfig = {
 			input: rolldownInput,
 			output: {
@@ -1577,6 +1628,7 @@ async function startRolldownWatch(config, ctx, bundleEntries) {
 				sourcemap: entry.sourcemap
 			},
 			platform: platform === "node" ? "node" : "neutral",
+			external: externalConfig,
 			transform: { target },
 			plugins: rolldownPlugins
 		};
@@ -1586,24 +1638,20 @@ async function startRolldownWatch(config, ctx, bundleEntries) {
 	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");
+				logger.info("Rebuilding...");
 				break;
+			case "BUNDLE_START": break;
+			case "BUNDLE_END": break;
 			case "END":
-				logger.success("🎉 Watch rebuild complete");
+				logger.success("Rebuilt");
 				break;
 			case "ERROR":
-				logger.error("❌ Build error:", event.error);
+				logger.error("Build error:", event.error);
 				break;
 		}
 	});
 	const cleanup = async () => {
-		consola.info("🛑 Stopping watch mode...");
+		logger.info("Stopping watch mode...");
 		await watcher.close();
 		process.exit(0);
 	};
@@ -1675,27 +1723,25 @@ async function build(config) {
 	if (config.logLevel) configureLogger(config.logLevel);
 	resetLogCounts();
 	const pkgDir = normalizePath(config.cwd);
-	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
 	const ctx = {
-		pkg,
+		pkg: await readJSON(join(pkgDir, "package.json")).catch(() => ({})),
 		pkgDir
 	};
 	let finalConfig = config;
 	if (config.fromVite) {
 		logger.verbose("Loading configuration from Vite config file");
-		const viteConfig = await loadViteConfig(pkgDir);
 		finalConfig = {
-			...viteConfig,
+			...await loadViteConfig(pkgDir),
 			...config
 		};
 	}
 	finalConfig = normalizeTsupConfig(finalConfig);
 	if (finalConfig.watch?.enabled) {
-		logger.info(`👀 Starting watch mode for \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+		logger.info(`Watching ${colors.cyan(ctx.pkg.name || "<unnamed>")}`);
 		await performWatchBuild(finalConfig, ctx, startTime);
 		return;
 	}
-	logger.info(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+	logger.info(`Building ${colors.cyan(ctx.pkg.name || "<unnamed>")}`);
 	await performBuild(finalConfig, ctx, startTime);
 }
 /**
@@ -1706,35 +1752,17 @@ async function performBuild(config, ctx, startTime) {
 	const hooks = config.hooks || {};
 	await hooks.start?.(ctx);
 	const entries = (config.entries || []).map((rawEntry) => {
-		let entry;
-		if (typeof rawEntry === "string") {
-			const [input, outDir] = rawEntry.split(":");
-			entry = input.endsWith("/") ? {
-				type: "transform",
-				input,
-				outDir
-			} : {
-				type: "bundle",
-				input: input.split(","),
-				outDir
-			};
-		} else entry = rawEntry;
+		let entry = typeof rawEntry === "string" ? parseEntryString(rawEntry) : rawEntry;
 		if (entry.type === "bundle") entry = inheritConfig(entry, config);
 		else if (entry.type === "transform") entry = inheritConfig(entry, config);
-		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)}`);
+		if (!hasValidInput(entry)) throw new Error(`Build entry missing \`input\` or \`entry\`: ${JSON.stringify(entry, null, 2)}`);
 		entry = { ...entry };
 		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
 		if (entry.type === "transform") {
 			if (entry.input) entry.input = normalizePath(entry.input, ctx.pkgDir);
 		} else {
-			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);
+			const entryInput = getBundleEntryInput(entry);
+			if (entryInput) entry.input = normalizeEntryInput(entryInput, ctx.pkgDir);
 		}
 		return entry;
 	});
@@ -1745,21 +1773,17 @@ async function performBuild(config, ctx, startTime) {
 	await hooks.end?.(ctx);
 	if (shouldFailOnWarnings(config.failOnWarn || false)) throw new Error("Build failed due to warnings");
 	const dirSize = analyzeDir(outDirs);
-	logger.info(colors.dim(`\nΣ Total dist byte size: ${colors.underline(prettyBytes(dirSize.size))} (${colors.underline(dirSize.files)} files)`));
+	logger.info(colors.dim(`\nTotal: ${colors.bold(prettyBytes(dirSize.size))} (${dirSize.files} files)`));
 	const duration = Date.now() - start;
-	logger.success(`\n✅ robuild finished in ${duration}ms`);
+	logger.success(`\nBuild succeeded in ${colors.bold(`${duration}ms`)}`);
 	if (config.onSuccess) {
 		const buildResult = createBuildResult([], startTime);
 		await executeOnSuccess(config.onSuccess, buildResult, ctx.pkgDir);
 	}
 }
-function normalizePath(path, resolveFrom) {
-	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
-}
 async function readJSON(specifier) {
-	const module = await import(specifier, { with: { type: "json" } });
-	return module.default;
+	return (await import(specifier, { with: { type: "json" } })).default;
 }
 
 //#endregion
-export { SHEBANG_RE, build, hasShebang, makeExecutable, nodeProtocolPlugin, performBuild, shebangPlugin };
+export { makeExecutable as a, configureLogger as c, hasShebang as i, logger as l, performBuild as n, shebangPlugin as o, SHEBANG_RE as r, nodeProtocolPlugin as s, build as t };