robuild 0.0.19 → 0.1.0

package/dist/_chunks/{build-snxBrML1.mjs → build-DbAuaVYJ.mjs}

@@ -1,26 +1,115 @@
 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
@@ -91,7 +180,7 @@ async function processFileUnbundled(inputPath, outputPath, entry) {
 		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);
 	}
 }
 /**
@@ -184,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({ codeSplitting: false });
+	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({ codeSplitting: false });
+	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
 /**
@@ -191,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);
@@ -201,12 +420,149 @@ 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
@@ -313,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;
@@ -321,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;
@@ -603,203 +959,74 @@ function addNodeProtocol(id) {
 	return id;
 }
 /**
-* Remove node: prefix from modules
-*/
-function stripNodeProtocol(id) {
-	if (id.startsWith("node:")) return id.slice(5);
-	return id;
-}
-/**
-* Process module ID based on nodeProtocol setting
-*/
-function processNodeProtocol(id, nodeProtocol) {
-	if (nodeProtocol === "strip") return stripNodeProtocol(id);
-	if (nodeProtocol === true) return addNodeProtocol(id);
-	return id;
-}
-/**
-* Transform import/export statements to handle node protocol
-*/
-function transformNodeProtocol(code, nodeProtocol) {
-	if (!nodeProtocol) return code;
-	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)) 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/utils.ts
-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) {
-		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
+* Remove node: prefix from modules
 */
-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";
-	}
+function stripNodeProtocol(id) {
+	if (id.startsWith("node:")) return id.slice(5);
+	return id;
 }
 /**
-* Clean output directory
+* Process module ID based on nodeProtocol setting
 */
-async function cleanOutputDir$1(projectRoot, outDir, cleanPaths) {
-	if (!cleanPaths) return;
-	const { rm } = await import("node:fs/promises");
-	const { existsSync } = await import("node:fs");
-	if (cleanPaths === true) {
-		if (existsSync(outDir)) {
-			consola.log(`🧻 Cleaning up ${fmtPath(outDir)}`);
-			await rm(outDir, {
-				recursive: true,
-				force: true
-			});
+function processNodeProtocol(id, nodeProtocol) {
+	if (nodeProtocol === "strip") return stripNodeProtocol(id);
+	if (nodeProtocol === true) return addNodeProtocol(id);
+	return id;
+}
+/**
+* Transform import/export statements to handle node protocol
+*/
+function transformNodeProtocol(code, nodeProtocol) {
+	if (!nodeProtocol) return code;
+	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
+			};
 		}
-	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
-		const fullPath = resolve(projectRoot, path);
-		if (existsSync(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);
@@ -817,16 +1044,16 @@ 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 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];
@@ -983,11 +1210,11 @@ 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) {
@@ -1026,111 +1253,30 @@ 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, 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/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 } = await import("node:fs");
-	if (cleanPaths === true) {
-		if (existsSync(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(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 } = await import("node:fs");
 	let inputDir = entry.input;
 	try {
 		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;
@@ -1183,7 +1329,7 @@ async function transformDir(ctx, entry) {
 	})());
 	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.
@@ -1268,89 +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() {
-		consola.level = {
-			silent: 0,
-			error: 1,
-			warn: 2,
-			info: 3,
-			verbose: 4
-		}[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);
@@ -1501,14 +1564,11 @@ 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 } = await import("./build-Cm8LX2zF.mjs");
+	const { performBuild } = await import("./build-tpynh1ZI.mjs");
 	await performBuild(config, ctx, startTime);
 	const bundleEntries = (config.entries || []).filter((entry) => {
 		if (typeof entry === "string") return !entry.endsWith("/");
@@ -1528,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...");
+	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",
@@ -1601,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);
 	};
@@ -1704,11 +1737,11 @@ async function build(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);
 }
 /**
@@ -1719,34 +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);
-		if (!(entry.type === "transform" ? !!entry.input : !!(entry.input || entry.entry))) 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;
 	});
@@ -1757,20 +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) {
 	return (await import(specifier, { with: { type: "json" } })).default;
 }
 
 //#endregion
-export { makeExecutable as a, hasShebang as i, performBuild as n, shebangPlugin as o, SHEBANG_RE as r, nodeProtocolPlugin as s, build as t };
+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 };

package/dist/_chunks/build-tpynh1ZI.mjs

@@ -0,0 +1,3 @@
+import { n as performBuild, t as build } from "./build-DbAuaVYJ.mjs";
+
+export { performBuild };

package/dist/_chunks/{package-DnMk3fWR.mjs → package-05zYHSH0.mjs}

@@ -2,7 +2,7 @@
 var package_default = {
 	name: "robuild",
 	type: "module",
-	version: "0.0.19",
+	version: "0.1.0",
 	packageManager: "pnpm@10.11.1",
 	description: "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc",
 	license: "MIT",

package/dist/cli.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
-import { t as build } from "./_chunks/build-snxBrML1.mjs";
+import { c as configureLogger, l as logger, t as build } from "./_chunks/build-DbAuaVYJ.mjs";
 import { colors } from "consola/utils";
-import { consola } from "consola";
 import process from "node:process";
 import { loadConfig } from "c12";
 import { cac } from "cac";
@@ -17,14 +16,13 @@ cli.command("[...entries]", "Bundle or transform files", {
 	try {
 		await runBuild(entries, flags);
 	} catch (error) {
-		consola.error(error);
+		logger.error(String(error));
 		process.exit(1);
 	}
 });
 async function runBuild(entries, flags) {
-	if (flags.logLevel) consola.level = flags.logLevel === "silent" ? 0 : flags.logLevel === "verbose" ? 5 : 3;
-	consola.info(`robuild ${colors.dim(`v${pkg.default.version}`)}`);
-	consola.info("");
+	if (flags.logLevel) configureLogger(flags.logLevel);
+	logger.info(`${colors.cyan("robuild")} ${colors.dim(`v${pkg.default.version}`)}`);
 	const configOptions = {
 		name: "robuild",
 		cwd: flags.dir || "."
@@ -102,8 +100,8 @@ async function runBuild(entries, flags) {
 	});
 	if (flags.stub) for (const entry of processedEntries) entry.stub = true;
 	if (rawEntries.length === 0) {
-		consola.error("No build entries specified.");
-		consola.info("Run `robuild --help` for usage information.");
+		logger.error("No build entries specified.");
+		logger.info("Run `robuild --help` for usage information.");
 		process.exit(1);
 	}
 	await build({
@@ -130,7 +128,7 @@ cli.parse(process.argv, { run: false });
 try {
 	await cli.runMatchedCommand();
 } catch (error) {
-	consola.error(error);
+	logger.error(String(error));
 	process.exit(1);
 }
 

package/dist/config.d.mts

@@ -13,7 +13,7 @@ type Platform = 'browser' | 'node' | 'neutral';
 /**
  * Target ES version
  */
-type Target = 'es5' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
+type Target = 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
 interface CopyEntry {
   from: string;
   to: string;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as makeExecutable, i as hasShebang, o as shebangPlugin, r as SHEBANG_RE, s as nodeProtocolPlugin, t as build } from "./_chunks/build-snxBrML1.mjs";
+import { a as makeExecutable, i as hasShebang, l as logger, o as shebangPlugin, r as SHEBANG_RE, s as nodeProtocolPlugin, t as build } from "./_chunks/build-DbAuaVYJ.mjs";
 import { defineConfig } from "./config.mjs";
 
 //#region src/features/plugin-utils.ts
@@ -132,7 +132,7 @@ function textPlugin(extensions = [".txt", ".md"]) {
 				const content = await readFile(id, "utf-8");
 				return `export default ${JSON.stringify(content)}`;
 			} catch (error) {
-				console.error(`Failed to load text file ${id}:`, error);
+				logger.error(`Failed to load text file ${id}:`, error);
 				return null;
 			}
 			return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robuild",
   "type": "module",
-  "version": "0.0.19",
+  "version": "0.1.0",
   "packageManager": "pnpm@10.11.1",
   "description": "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc",
   "license": "MIT",

package/dist/_chunks/build-Cm8LX2zF.mjs

@@ -1,3 +0,0 @@
-import { n as performBuild, t as build } from "./build-snxBrML1.mjs";
-
-export { performBuild };