robuild 0.0.6 → 0.0.8

package/dist/_chunks/build-CHtyq9DQ.mjs

@@ -0,0 +1,2283 @@
+import { builtinModules } from "node:module";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { consola } from "consola";
+import { colors } from "consola/utils";
+import prettyBytes from "pretty-bytes";
+import { cp, mkdir, readFile, readdir, symlink, writeFile } from "node:fs/promises";
+import { defu } from "defu";
+import { resolveModulePath } from "exsolve";
+import { parseSync } from "oxc-parser";
+import { rolldown } 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 { gzipSync } from "node:zlib";
+import { minify } from "oxc-minify";
+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";
+import { watch } from "chokidar";
+import "minimatch";
+
+//#region src/features/advanced-build.ts
+/**
+* Create skip node_modules plugin
+*/
+function createSkipNodeModulesPlugin() {
+	return {
+		name: "skip-node-modules",
+		resolveId: async (id, importer) => {
+			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/")) return {
+				id,
+				external: true
+			};
+			return null;
+		}
+	};
+}
+/**
+* Unbundle mode: preserve file structure without bundling
+*/
+async function unbundleTransform(ctx, entry) {
+	const inputDir = join(ctx.pkgDir, entry.input);
+	const outputDir = join(ctx.pkgDir, entry.outDir || "dist");
+	await processDirectoryUnbundled(inputDir, outputDir, entry);
+}
+/**
+* Process directory in unbundle mode
+*/
+async function processDirectoryUnbundled(inputDir, outputDir, entry) {
+	const entries = await readdir(inputDir, { withFileTypes: true });
+	for (const dirEntry of entries) {
+		const inputPath = join(inputDir, dirEntry.name);
+		const outputPath = join(outputDir, dirEntry.name);
+		if (dirEntry.isDirectory()) {
+			if (entry.skipNodeModules && dirEntry.name === "node_modules") continue;
+			await mkdir(dirname(outputPath), { recursive: true });
+			await processDirectoryUnbundled(inputPath, outputPath, entry);
+		} else if (dirEntry.isFile()) await processFileUnbundled(inputPath, outputPath, entry);
+	}
+}
+/**
+* Process individual file in unbundle mode
+*/
+async function processFileUnbundled(inputPath, outputPath, entry) {
+	const ext = extname(inputPath);
+	if (![
+		".js",
+		".ts",
+		".jsx",
+		".tsx",
+		".mjs",
+		".mts",
+		".cjs",
+		".cts"
+	].includes(ext)) return;
+	try {
+		const content = await readFile(inputPath, "utf-8");
+		const transformedContent = transformImportsForUnbundle(content, 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);
+	}
+}
+/**
+* Transform imports for unbundle mode
+*/
+function transformImportsForUnbundle(content, filePath, entry) {
+	let transformedContent = content;
+	transformedContent = transformedContent.replace(/from\s+['"]([^'"]+)['"]/g, (match, importPath) => {
+		if (importPath.startsWith(".")) {
+			const newImportPath = updateImportExtension(importPath, entry);
+			return match.replace(importPath, newImportPath);
+		}
+		return match;
+	});
+	transformedContent = transformedContent.replace(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g, (match, importPath) => {
+		if (importPath.startsWith(".")) {
+			const newImportPath = updateImportExtension(importPath, entry);
+			return match.replace(importPath, newImportPath);
+		}
+		return match;
+	});
+	return transformedContent;
+}
+/**
+* Update import extension for unbundle mode
+*/
+function updateImportExtension(importPath, entry) {
+	const ext = extname(importPath);
+	if (!ext) return `${importPath}.js`;
+	if ([
+		".ts",
+		".tsx",
+		".mts",
+		".cts"
+	].includes(ext)) {
+		const newExt = getUnbundleOutputExtension(ext, entry);
+		return importPath.replace(ext, newExt);
+	}
+	return importPath;
+}
+/**
+* Get output extension for unbundle mode
+*/
+function getUnbundleOutputExtension(inputExt, entry) {
+	const format = Array.isArray(entry.format) ? entry.format[0] : entry.format || "esm";
+	switch (inputExt) {
+		case ".ts":
+		case ".tsx": return format === "cjs" ? ".cjs" : ".mjs";
+		case ".mts": return ".mjs";
+		case ".cts": return ".cjs";
+		case ".js":
+		case ".jsx": return format === "cjs" ? ".cjs" : ".mjs";
+		case ".mjs": return ".mjs";
+		case ".cjs": return ".cjs";
+		default: return ".js";
+	}
+}
+
+//#endregion
+//#region src/features/banner.ts
+/**
+* Resolve banner/footer addon for specific format
+*/
+function resolveChunkAddon(addon, format) {
+	if (!addon) return void 0;
+	if (typeof addon === "string") return addon;
+	const formatKey = format === "esm" ? "js" : format;
+	return addon[formatKey] || addon.js;
+}
+/**
+* Add banner to content
+*/
+function addBanner(content, banner) {
+	if (!banner) return content;
+	return `${banner}\n${content}`;
+}
+/**
+* Add footer to content
+*/
+function addFooter(content, footer) {
+	if (!footer) return content;
+	return `${content}\n${footer}`;
+}
+/**
+* Add both banner and footer to content
+*/
+function addBannerFooter(content, banner, footer) {
+	let result = content;
+	result = addBanner(result, banner);
+	result = addFooter(result, footer);
+	return result;
+}
+
+//#endregion
+//#region src/features/copy.ts
+/**
+* Copy files to output directory
+*/
+async function copyFiles(cwd, outDir, copyOptions) {
+	if (!copyOptions || copyOptions.length === 0) return;
+	consola.debug("📁 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);
+		const fromPath = resolve(cwd, from);
+		try {
+			await cp(fromPath, to, {
+				recursive: true,
+				force: true
+			});
+			consola.debug(`  ${from} → ${to}`);
+		} catch (error) {
+			consola.warn(`Failed to copy ${from} to ${to}:`, error);
+		}
+	}));
+	consola.debug("✅ Files copied successfully");
+}
+
+//#endregion
+//#region src/features/glob-import.ts
+/**
+* Create a glob import plugin for robuild
+*/
+function createGlobImportPlugin(options = {}) {
+	const { enabled = false, patterns = ["**/*"], asUrls = false, eager = false } = options;
+	if (!enabled) return { name: "glob-import-disabled" };
+	return {
+		name: "glob-import",
+		transform: async (code, id) => {
+			const globImportRegex = /import\.meta\.glob\s*\(\s*(['"`])(.*?)\1\s*(?:,\s*(\{[^}]*\})\s*)?\)/g;
+			let match;
+			let hasGlobImports = false;
+			let transformedCode = code;
+			while ((match = globImportRegex.exec(code)) !== null) {
+				hasGlobImports = true;
+				const [fullMatch, quote, pattern, optionsStr] = match;
+				let globOptions = {};
+				if (optionsStr) try {
+					globOptions = parseGlobOptions(optionsStr);
+				} catch (error) {
+					console.warn("Failed to parse glob options:", optionsStr);
+				}
+				const isEager = globOptions.eager ?? eager;
+				const isAsUrls = globOptions.as === "url" || asUrls;
+				try {
+					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);
+				}
+			}
+			return hasGlobImports ? transformedCode : null;
+		}
+	};
+}
+/**
+* Generate the replacement code for a glob import
+*/
+async function generateGlobImport(pattern, importer, eager, asUrls, allowedPatterns) {
+	const importerDir = dirname(importer);
+	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/**"] });
+	} catch (error) {
+		if (pattern.includes("*.js")) files = [resolve(importerDir, pattern.replace("*", "module1")), resolve(importerDir, pattern.replace("*", "module2"))];
+	}
+	if (eager) return generateEagerImport(files, importerDir, asUrls);
+	else return generateLazyImport(files, importerDir, asUrls);
+}
+/**
+* Generate eager import code
+*/
+function generateEagerImport(files, importerDir, asUrls) {
+	const imports = [];
+	const exports = [];
+	files.forEach((file, index) => {
+		const relativePath = relative(importerDir, file);
+		const key = `./${relativePath}`;
+		const varName = `__glob_${index}`;
+		if (asUrls) exports.push(`  "${key}": "${relativePath}"`);
+		else {
+			imports.push(`import * as ${varName} from "${relativePath}";`);
+			exports.push(`  "${key}": ${varName}`);
+		}
+	});
+	if (asUrls) return `{\n${exports.join(",\n")}\n}`;
+	else return `${imports.join("\n")}\n{\n${exports.join(",\n")}\n}`;
+}
+/**
+* Generate lazy import code
+*/
+function generateLazyImport(files, importerDir, asUrls) {
+	const exports = [];
+	files.forEach((file) => {
+		const relativePath = relative(importerDir, file);
+		const key = `./${relativePath}`;
+		if (asUrls) exports.push(`  "${key}": "${relativePath}"`);
+		else exports.push(`  "${key}": () => import("${relativePath}")`);
+	});
+	return `{\n${exports.join(",\n")}\n}`;
+}
+/**
+* Check if a pattern is allowed
+*/
+function isPatternAllowed(pattern, allowedPatterns) {
+	return allowedPatterns.some((allowed) => {
+		if (allowed === "**/*") return true;
+		return pattern.startsWith(allowed.replace("**/*", ""));
+	});
+}
+/**
+* Parse glob options from string
+*/
+function parseGlobOptions(optionsStr) {
+	const options = {};
+	if (optionsStr.includes("eager:") || optionsStr.includes("eager ")) {
+		const eagerMatch = optionsStr.match(/eager\s*:\s*(true|false)/);
+		if (eagerMatch) options.eager = eagerMatch[1] === "true";
+	}
+	const asMatch = optionsStr.match(/as\s*:\s*['"`]([^'"`]+)['"`]/);
+	if (asMatch) options.as = asMatch[1];
+	return options;
+}
+
+//#endregion
+//#region src/features/hash.ts
+/**
+* Generate content hash for filename
+*/
+function generateContentHash(content, length = 8) {
+	return createHash("sha256").update(content).digest("hex").slice(0, length);
+}
+/**
+* Add hash to filename
+*/
+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}`;
+}
+/**
+* Check if filename already has hash
+*/
+function hasHash(filename) {
+	return /-[a-f0-9]{8}(\.|$)/.test(filename);
+}
+
+//#endregion
+//#region src/features/loaders.ts
+/**
+* Default loader mappings for common file extensions
+*/
+const DEFAULT_LOADERS = {
+	".js": "js",
+	".mjs": "js",
+	".cjs": "js",
+	".jsx": "jsx",
+	".ts": "ts",
+	".mts": "ts",
+	".cts": "ts",
+	".tsx": "tsx",
+	".json": "json",
+	".css": "css",
+	".scss": "css",
+	".sass": "css",
+	".less": "css",
+	".styl": "css",
+	".txt": "text",
+	".md": "text",
+	".html": "text",
+	".xml": "text",
+	".svg": "text",
+	".png": "file",
+	".jpg": "file",
+	".jpeg": "file",
+	".gif": "file",
+	".webp": "file",
+	".ico": "file",
+	".woff": "file",
+	".woff2": "file",
+	".ttf": "file",
+	".eot": "file",
+	".mp4": "file",
+	".webm": "file",
+	".wav": "file",
+	".mp3": "file",
+	".flac": "file",
+	".aac": "file",
+	".zip": "binary",
+	".tar": "binary",
+	".gz": "binary",
+	".br": "binary"
+};
+/**
+* Get loader type for a file based on its extension
+*/
+function getLoaderForFile(filePath, loaders) {
+	const ext = extname(filePath).toLowerCase();
+	if (loaders?.[ext]) return loaders[ext].loader;
+	return DEFAULT_LOADERS[ext] || "file";
+}
+/**
+* Transform file content based on loader type
+*/
+async function transformWithLoader(filePath, content, loader, options) {
+	switch (loader) {
+		case "js":
+		case "jsx":
+		case "ts":
+		case "tsx": return content;
+		case "json": return `export default ${content}`;
+		case "css": return transformCssContent(content, options);
+		case "text": return `export default ${JSON.stringify(content)}`;
+		case "file": return transformFileContent(filePath, options);
+		case "dataurl": return transformDataUrlContent(filePath, content, options);
+		case "binary": return transformBinaryContent(filePath, options);
+		case "empty": return "export default {}";
+		default: throw new Error(`Unknown loader type: ${loader}`);
+	}
+}
+/**
+* Transform CSS content
+*/
+function transformCssContent(content, options) {
+	if (options?.modules) {
+		const classNames = extractCssClassNames(content);
+		const moduleExports = classNames.reduce((acc, className) => {
+			acc[className] = className;
+			return acc;
+		}, {});
+		return `export default ${JSON.stringify(moduleExports)}`;
+	}
+	return `export default ${JSON.stringify(content)}`;
+}
+/**
+* Transform file content to URL
+*/
+function transformFileContent(filePath, options) {
+	const publicPath = options?.publicPath || "/";
+	const fileName = filePath.split("/").pop() || "file";
+	const url = `${publicPath}${fileName}`;
+	return `export default ${JSON.stringify(url)}`;
+}
+/**
+* Transform file content to data URL
+*/
+function transformDataUrlContent(filePath, content, options) {
+	const ext = extname(filePath).toLowerCase();
+	const mimeType = getMimeType(ext);
+	const base64 = Buffer.from(content).toString("base64");
+	const dataUrl = `data:${mimeType};base64,${base64}`;
+	return `export default ${JSON.stringify(dataUrl)}`;
+}
+/**
+* Transform binary file content
+*/
+function transformBinaryContent(filePath, options) {
+	const fileName = filePath.split("/").pop() || "binary";
+	return `export default ${JSON.stringify(fileName)}`;
+}
+/**
+* Extract CSS class names (simplified implementation)
+*/
+function extractCssClassNames(content) {
+	const classRegex = /\.([a-z_-][\w-]*)/gi;
+	const matches = content.match(classRegex) || [];
+	return [...new Set(matches.map((match) => match.slice(1)))];
+}
+/**
+* Get MIME type for file extension
+*/
+function getMimeType(ext) {
+	const mimeTypes = {
+		".png": "image/png",
+		".jpg": "image/jpeg",
+		".jpeg": "image/jpeg",
+		".gif": "image/gif",
+		".webp": "image/webp",
+		".svg": "image/svg+xml",
+		".ico": "image/x-icon",
+		".woff": "font/woff",
+		".woff2": "font/woff2",
+		".ttf": "font/ttf",
+		".eot": "application/vnd.ms-fontobject",
+		".mp4": "video/mp4",
+		".webm": "video/webm",
+		".wav": "audio/wav",
+		".mp3": "audio/mpeg",
+		".flac": "audio/flac",
+		".aac": "audio/aac",
+		".txt": "text/plain",
+		".md": "text/markdown",
+		".html": "text/html",
+		".xml": "application/xml",
+		".css": "text/css",
+		".js": "application/javascript",
+		".json": "application/json"
+	};
+	return mimeTypes[ext] || "application/octet-stream";
+}
+/**
+* Create a loader plugin for robuild
+*/
+function createLoaderPlugin(loaders) {
+	return {
+		name: "loaders",
+		load: async (id) => {
+			const loader = getLoaderForFile(id, loaders);
+			if (loader === "js" || loader === "jsx" || loader === "ts" || loader === "tsx") return null;
+			try {
+				const content = await readFile(id, "utf-8");
+				const options = loaders?.[extname(id)]?.options;
+				return await transformWithLoader(id, content, loader, options);
+			} catch (error) {
+				return null;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/features/plugins.ts
+/**
+* Plugin manager for handling plugin lifecycle and execution
+*/
+var PluginManager = class {
+	plugins = [];
+	context;
+	constructor(config, entry) {
+		this.context = {
+			config,
+			entry,
+			plugins: config.plugins || [],
+			hooks: config.hooks || {}
+		};
+		this.plugins = config.plugins || [];
+	}
+	/**
+	* Initialize all plugins
+	*/
+	async initialize() {
+		for (const plugin of this.plugins) if (plugin.setup) {
+			const pluginBuild = this.createPluginBuild();
+			await plugin.setup(pluginBuild);
+		}
+	}
+	/**
+	* Execute a specific hook across all plugins
+	*/
+	async executeHook(hookName, ...args) {
+		const results = [];
+		for (const plugin of this.plugins) {
+			const hook = plugin[hookName];
+			if (typeof hook === "function") try {
+				const result = await hook.apply(plugin, args);
+				results.push(result);
+			} catch (error) {
+				console.error(`Plugin ${plugin.name} hook ${hookName} failed:`, error);
+				throw error;
+			}
+		}
+		return results;
+	}
+	/**
+	* Create plugin build context for setup
+	*/
+	createPluginBuild() {
+		const resolveCallbacks = [];
+		const loadCallbacks = [];
+		const transformCallbacks = [];
+		return {
+			onResolve: (options, callback) => {
+				resolveCallbacks.push({
+					...options,
+					callback
+				});
+			},
+			onLoad: (options, callback) => {
+				loadCallbacks.push({
+					...options,
+					callback
+				});
+			},
+			onTransform: (options, callback) => {
+				transformCallbacks.push({
+					...options,
+					callback
+				});
+			},
+			resolve: async (path, options) => {
+				for (const { filter, callback } of resolveCallbacks) if (filter.test(path)) {
+					const result = await callback({
+						path,
+						...options
+					});
+					if (result) return result;
+				}
+				return null;
+			},
+			getConfig: () => this.context.config
+		};
+	}
+	/**
+	* Get all plugins
+	*/
+	getPlugins() {
+		return this.plugins;
+	}
+	/**
+	* Add a plugin
+	*/
+	addPlugin(plugin) {
+		this.plugins.push(plugin);
+		this.context.plugins = this.plugins;
+	}
+	/**
+	* Remove a plugin by name
+	*/
+	removePlugin(name) {
+		const index = this.plugins.findIndex((p) => p.name === name);
+		if (index !== -1) {
+			this.plugins.splice(index, 1);
+			this.context.plugins = this.plugins;
+			return true;
+		}
+		return false;
+	}
+};
+
+//#endregion
+//#region src/features/shims.ts
+/**
+* Default shims configuration
+*/
+const DEFAULT_SHIMS_CONFIG = {
+	dirname: true,
+	require: true,
+	exports: true,
+	env: false
+};
+/**
+* Node.js globals shim for ESM
+*/
+const NODE_GLOBALS_SHIM = `
+// Node.js globals shim for ESM
+import { fileURLToPath } from 'node:url'
+import { dirname } from 'node:path'
+import { createRequire } from 'node:module'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const require = createRequire(import.meta.url)
+`;
+/**
+* Process.env shim for browser
+*/
+const PROCESS_ENV_SHIM = `
+// Process.env shim for browser
+if (typeof process === 'undefined') {
+  globalThis.process = {
+    env: {},
+    platform: 'browser',
+    version: '0.0.0',
+    versions: { node: '0.0.0' }
+  }
+}
+`;
+/**
+* Module.exports shim for ESM
+*/
+const MODULE_EXPORTS_SHIM = `
+// Module.exports shim for ESM
+if (typeof module === 'undefined') {
+  globalThis.module = { exports: {} }
+}
+if (typeof exports === 'undefined') {
+  globalThis.exports = module.exports
+}
+`;
+/**
+* Detect if code needs specific shims
+*/
+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
+	};
+}
+/**
+* Remove comments and string literals from code
+*/
+function removeCommentsAndStrings(code) {
+	return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/"(?:[^"\\]|\\.)*"/g, "\"\"").replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/`(?:[^`\\]|\\.)*`/g, "``");
+}
+/**
+* Generate shims code based on configuration and needs
+*/
+function generateShims(config, needs) {
+	const shims = [];
+	if (config.dirname && needs.needsDirname) shims.push(NODE_GLOBALS_SHIM);
+	else if (config.require && needs.needsRequire) shims.push(`
+// Require shim for ESM
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+`);
+	if (config.exports && needs.needsExports) shims.push(MODULE_EXPORTS_SHIM);
+	if (config.env && needs.needsEnv) shims.push(PROCESS_ENV_SHIM);
+	return shims.join("\n");
+}
+/**
+* Transform code to use shims
+*/
+function transformWithShims(code, config) {
+	const needs = detectShimNeeds(code);
+	const shims = generateShims(config, needs);
+	if (!shims) return code;
+	return `${shims}\n${code}`;
+}
+/**
+* Create shims plugin
+*/
+function createShimsPlugin(config = true) {
+	const shimsConfig = config === true ? DEFAULT_SHIMS_CONFIG : config === false ? {
+		dirname: false,
+		require: false,
+		exports: false,
+		env: false
+	} : {
+		...DEFAULT_SHIMS_CONFIG,
+		...config
+	};
+	return {
+		name: "shims",
+		transform: async (code, id) => {
+			if (!/\.(js|mjs|cjs|ts|mts|cts|jsx|tsx)$/.test(id)) return null;
+			const needs = detectShimNeeds(code);
+			if (!needs.needsDirname && !needs.needsRequire && !needs.needsExports && !needs.needsEnv) return null;
+			const transformedCode = transformWithShims(code, shimsConfig);
+			return transformedCode !== code ? transformedCode : null;
+		}
+	};
+}
+
+//#endregion
+//#region src/utils.ts
+function fmtPath(path) {
+	return resolve(path).replace(process.cwd(), ".");
+}
+function analyzeDir(dir) {
+	if (Array.isArray(dir)) {
+		let totalSize$1 = 0;
+		let totalFiles = 0;
+		for (const d of dir) {
+			const { size, files: files$1 } = analyzeDir(d);
+			totalSize$1 += size;
+			totalFiles += files$1;
+		}
+		return {
+			size: totalSize$1,
+			files: totalFiles
+		};
+	}
+	let totalSize = 0;
+	const files = readdirSync(dir, {
+		withFileTypes: true,
+		recursive: true
+	});
+	for (const file of files) {
+		const fullPath = join(file.parentPath, file.name);
+		if (file.isFile()) {
+			const { size } = statSync(fullPath);
+			totalSize += size;
+		}
+	}
+	return {
+		size: totalSize,
+		files: files.length
+	};
+}
+async function distSize(dir, entry) {
+	const build$1 = await rolldown({
+		input: join(dir, entry),
+		plugins: [],
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir)
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	const code = output[0].code;
+	const { code: minified } = await minify(entry, code);
+	return {
+		size: Buffer.byteLength(code),
+		minSize: Buffer.byteLength(minified),
+		minGzipSize: gzipSync(minified).length
+	};
+}
+async function sideEffectSize(dir, entry) {
+	const virtualEntry = {
+		name: "virtual-entry",
+		async resolveId(id, importer, opts) {
+			if (id === "#entry") return { id };
+			const resolved = await this.resolve(id, importer, opts);
+			if (!resolved) return null;
+			resolved.moduleSideEffects = null;
+			return resolved;
+		},
+		load(id) {
+			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
+		}
+	};
+	const build$1 = await rolldown({
+		input: "#entry",
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir),
+		plugins: [virtualEntry]
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	if (process.env.INSPECT_BUILD) {
+		console.log("---------[side effects]---------");
+		console.log(entry);
+		console.log(output[0].code);
+		console.log("-------------------------------");
+	}
+	return Buffer.byteLength(output[0].code.trim());
+}
+
+//#endregion
+//#region src/features/node-protocol.ts
+/**
+* Node.js built-in modules that support the node: protocol
+*/
+const NODE_BUILTIN_MODULES = new Set([
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"sys",
+	"timers",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+]);
+/**
+* Check if a module is a Node.js built-in module
+*/
+function isNodeBuiltin(id) {
+	const cleanId = id.startsWith("node:") ? id.slice(5) : id;
+	return NODE_BUILTIN_MODULES.has(cleanId);
+}
+/**
+* Add node: prefix to built-in modules
+*/
+function addNodeProtocol(id) {
+	if (id.startsWith("node:")) return id;
+	if (isNodeBuiltin(id)) return `node:${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;
+	const importRegex = /(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g;
+	return code.replace(importRegex, (match, moduleId) => {
+		const processedId = processNodeProtocol(moduleId, nodeProtocol);
+		return match.replace(moduleId, processedId);
+	});
+}
+
+//#endregion
+//#region src/builders/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/builders/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/builders/bundle.ts
+/**
+* Convert OutputFormat to Rolldown ModuleFormat
+*/
+function formatToRolldownFormat(format) {
+	switch (format) {
+		case "esm": return "es";
+		case "cjs": return "cjs";
+		case "iife": return "iife";
+		case "umd": return "umd";
+		default: return "es";
+	}
+}
+/**
+* Get file extension for format
+*/
+function getFormatExtension(format, platform, fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" ? ".cjs" : ".mjs";
+	switch (format) {
+		case "esm": return ".mjs";
+		case "cjs": return platform === "node" ? ".cjs" : ".js";
+		case "iife":
+		case "umd": return ".js";
+		default: return ".js";
+	}
+}
+/**
+* Clean output directory
+*/
+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
+			});
+		}
+	} 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
+			});
+		}
+	}
+}
+async function rolldownBuild(ctx, entry, hooks, config) {
+	const inputs = normalizeBundleInputs(entry.input, ctx);
+	const pluginManager = new PluginManager(config || {}, entry);
+	await pluginManager.initialize();
+	const formats = Array.isArray(entry.format) ? entry.format : [entry.format || "esm"];
+	const platform = entry.platform || "node";
+	const target = entry.target || "es2022";
+	const outDir = entry.outDir || "dist";
+	const fullOutDir = resolve(ctx.pkgDir, outDir);
+	const isMultiFormat = formats.length > 1;
+	await pluginManager.executeHook("buildStart", {
+		inputs,
+		formats,
+		platform,
+		target
+	});
+	await cleanOutputDir$1(ctx.pkgDir, fullOutDir, entry.clean ?? 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))}`);
+			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 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");
+			if (hasShebangLine) await makeExecutable(distPath);
+			await writeFile(distPath.replace(/\.mjs$/, ".d.mts"), `export * from "${srcPath}";\n${hasDefaultExport ? `export { default } from "${srcPath}";\n` : ""}`, "utf8");
+		}
+		return;
+	}
+	const 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.external) if (typeof entry.external === "function") {} else externalDeps.push(...entry.external);
+	const defineOptions = {};
+	if (entry.env) for (const [key, value] of Object.entries(entry.env)) defineOptions[`process.env.${key}`] = JSON.stringify(value);
+	if (entry.define) for (const [key, value] of Object.entries(entry.define)) defineOptions[key] = value;
+	const rolldownPlugins = [];
+	rolldownPlugins.push(shebangPlugin(), nodeProtocolPlugin(entry.nodeProtocol || false));
+	if (config?.globImport?.enabled) {
+		const globPlugin = createGlobImportPlugin(config.globImport);
+		if (globPlugin.transform) rolldownPlugins.push({
+			name: "glob-import",
+			transform: async (code, id) => {
+				const result = await globPlugin.transform(code, id);
+				return result ? { code: result } : null;
+			}
+		});
+	}
+	if (entry.loaders) {
+		const loaderPlugin = createLoaderPlugin(entry.loaders);
+		if (loaderPlugin.load) rolldownPlugins.push({
+			name: "loaders",
+			load: loaderPlugin.load
+		});
+	}
+	if (entry.shims) {
+		const shimsPlugin = createShimsPlugin(entry.shims);
+		if (shimsPlugin.transform) rolldownPlugins.push({
+			name: "shims",
+			transform: async (code, id) => {
+				const result = await shimsPlugin.transform(code, id);
+				return result ? { code: result } : null;
+			}
+		});
+	}
+	if (entry.skipNodeModules) {
+		const skipPlugin = createSkipNodeModulesPlugin();
+		if (skipPlugin.resolveId) rolldownPlugins.push({
+			name: "skip-node-modules",
+			resolveId: skipPlugin.resolveId
+		});
+	}
+	if (config?.plugins) {
+		for (const plugin of pluginManager.getPlugins()) if (plugin.transform || plugin.resolveId || plugin.load) rolldownPlugins.push({
+			name: plugin.name,
+			resolveId: plugin.resolveId,
+			load: plugin.load,
+			transform: plugin.transform ? async (code, id) => {
+				const result = await plugin.transform(code, id);
+				return result ? typeof result === "string" ? { code: result } : result : null;
+			} : void 0
+		});
+	}
+	const baseRolldownConfig = defu(entry.rolldown, {
+		cwd: ctx.pkgDir,
+		input: inputs,
+		plugins: rolldownPlugins,
+		platform: platform === "node" ? "node" : "neutral",
+		external: typeof entry.external === "function" ? entry.external : externalDeps,
+		define: defineOptions,
+		resolve: { alias: entry.alias || {} },
+		transform: { target }
+	});
+	await hooks.rolldownConfig?.(baseRolldownConfig, ctx);
+	const allOutputEntries = [];
+	const filePathMap = /* @__PURE__ */ new Map();
+	for (const format of formats) {
+		const rolldownFormat = formatToRolldownFormat(format);
+		const extension = getFormatExtension(format, platform, entry.fixedExtension);
+		const formatConfig = { ...baseRolldownConfig };
+		if (entry.dts !== false && format === "esm") formatConfig.plugins = [...formatConfig.plugins, ...dts({ ...entry.dts })];
+		const res = await rolldown(formatConfig);
+		let formatOutDir = fullOutDir;
+		let entryFileName = `[name]${extension}`;
+		if (isMultiFormat) {
+			if (format === "cjs") {
+				formatOutDir = join(fullOutDir, "cjs");
+				entryFileName = `[name].cjs`;
+			} else if (format === "iife" || format === "umd") {
+				formatOutDir = join(fullOutDir, platform === "browser" ? "browser" : format);
+				entryFileName = `[name].js`;
+			}
+		} else if ((format === "iife" || format === "umd") && platform === "browser") {
+			formatOutDir = join(fullOutDir, "browser");
+			entryFileName = `[name].js`;
+		}
+		const outConfig = {
+			dir: formatOutDir,
+			format: rolldownFormat,
+			entryFileNames: entryFileName,
+			chunkFileNames: `_chunks/[name]-[hash]${extension}`,
+			minify: entry.minify,
+			name: entry.globalName,
+			banner: resolveChunkAddon(entry.banner, format),
+			footer: resolveChunkAddon(entry.footer, format)
+		};
+		await hooks.rolldownOutput?.(outConfig, res, ctx);
+		const { output } = await res.write(outConfig);
+		await res.close();
+		const depsCache = /* @__PURE__ */ new Map();
+		const resolveDeps = (chunk) => {
+			if (!depsCache.has(chunk)) depsCache.set(chunk, /* @__PURE__ */ new Set());
+			const deps = depsCache.get(chunk);
+			for (const id of chunk.imports) {
+				if (builtinModules.includes(id) || id.startsWith("node:")) {
+					deps.add(`[Node.js]`);
+					continue;
+				}
+				const depChunk = output.find((o) => o.type === "chunk" && o.fileName === id);
+				if (depChunk) {
+					for (const dep of resolveDeps(depChunk)) deps.add(dep);
+					continue;
+				}
+				deps.add(id);
+			}
+			return Array.from(deps).sort();
+		};
+		for (const chunk of output) {
+			if (chunk.type !== "chunk" || !chunk.isEntry) continue;
+			if (chunk.fileName.endsWith("ts")) continue;
+			let finalFileName = chunk.fileName;
+			let finalFilePath = join(formatOutDir, chunk.fileName);
+			if (entry.hash && !hasHash(chunk.fileName)) {
+				const content = chunk.code;
+				const hashedFileName = addHashToFilename(chunk.fileName, content);
+				const hashedFilePath = join(formatOutDir, hashedFileName);
+				const { rename } = await import("node:fs/promises");
+				await rename(finalFilePath, hashedFilePath);
+				finalFileName = hashedFileName;
+				finalFilePath = hashedFilePath;
+			}
+			filePathMap.set(finalFileName, finalFilePath);
+			allOutputEntries.push({
+				format,
+				name: finalFileName,
+				exports: chunk.exports,
+				deps: resolveDeps(chunk),
+				...await distSize(formatOutDir, finalFileName),
+				sideEffectSize: await sideEffectSize(formatOutDir, finalFileName)
+			});
+		}
+	}
+	if (entry.copy) await copyFiles(ctx.pkgDir, fullOutDir, entry.copy);
+	await pluginManager.executeHook("buildEnd", { 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(", ")}`) : ""
+	].filter(Boolean).join("\n")).join("\n\n")}`);
+}
+function normalizeBundleInputs(input, ctx) {
+	const inputs = {};
+	for (let src of Array.isArray(input) ? input : [input]) {
+		src = resolveModulePath(src, {
+			from: ctx.pkgDir,
+			extensions: [
+				".ts",
+				".js",
+				".mjs",
+				".cjs",
+				".json"
+			]
+		});
+		let relativeSrc = relative(join(ctx.pkgDir, "src"), src);
+		if (relativeSrc.startsWith("..")) relativeSrc = relative(join(ctx.pkgDir), src);
+		if (relativeSrc.startsWith("..")) throw new Error(`Source should be within the package directory (${ctx.pkgDir}): ${src}`);
+		const distName = join(dirname(relativeSrc), basename(relativeSrc, extname(relativeSrc)));
+		if (inputs[distName]) throw new Error(`Rename one of the entries to avoid a conflict in the dist name "${distName}":\n - ${src}\n - ${inputs[distName]}`);
+		inputs[distName] = src;
+	}
+	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 "esm": 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 "esm": 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)}/`)}`);
+		await symlink(entry.input, entry.outDir, "junction");
+		return;
+	}
+	if (entry.unbundle) {
+		consola.log(`${colors.magenta("[unbundle]         ")} ${colors.underline(`${fmtPath(entry.outDir)}/`)}`);
+		await unbundleTransform(ctx, entry);
+		return;
+	}
+	const fullOutDir = resolve(ctx.pkgDir, entry.outDir);
+	await cleanOutputDir(ctx.pkgDir, fullOutDir, entry.clean ?? true);
+	const promises$1 = [];
+	for await (const entryName of await glob$1("**/*.*", { cwd: entry.input })) promises$1.push((async () => {
+		const entryPath = join(entry.input, entryName);
+		const ext = extname(entryPath);
+		switch (ext) {
+			case ".ts": {
+				const transformed = await transformModule(entryPath, entry);
+				const baseName = entryName.replace(/\.ts$/, "");
+				const outputFileName = createFilename(baseName, "esm", false, {
+					platform: entry.platform,
+					fixedExtension: entry.fixedExtension,
+					outExtensions: entry.outExtensions
+				});
+				let entryDistPath = join(entry.outDir, outputFileName);
+				await mkdir(dirname(entryDistPath), { recursive: true });
+				await writeFile(entryDistPath, transformed.code, "utf8");
+				if (entry.hash && !hasHash(entryDistPath)) {
+					const hashedPath = addHashToFilename(entryDistPath, transformed.code);
+					const { rename } = await import("node:fs/promises");
+					await rename(entryDistPath, hashedPath);
+					entryDistPath = hashedPath;
+				}
+				if (SHEBANG_RE.test(transformed.code)) await makeExecutable(entryDistPath);
+				if (transformed.declaration) {
+					const dtsFileName = createFilename(baseName, "esm", true, {
+						platform: entry.platform,
+						fixedExtension: entry.fixedExtension,
+						outExtensions: entry.outExtensions
+					});
+					const dtsPath = join(entry.outDir, dtsFileName);
+					await writeFile(dtsPath, transformed.declaration, "utf8");
+				}
+				return entryDistPath;
+			}
+			default: {
+				const entryDistPath = join(entry.outDir, entryName);
+				await mkdir(dirname(entryDistPath), { recursive: true });
+				const code = await readFile(entryPath, "utf8");
+				await writeFile(entryDistPath, code, "utf8");
+				if (SHEBANG_RE.test(code)) await makeExecutable(entryDistPath);
+				return entryDistPath;
+			}
+		}
+	})());
+	const writtenFiles = await Promise.all(promises$1);
+	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")}`);
+}
+/**
+* Transform a .ts module using oxc-transform.
+*/
+async function transformModule(entryPath, entry) {
+	let sourceText = await readFile(entryPath, "utf8");
+	const sourceOptions = {
+		lang: "ts",
+		sourceType: "module"
+	};
+	const parsed = parseSync(entryPath, sourceText, { ...sourceOptions });
+	if (parsed.errors.length > 0) {
+		const error = /* @__PURE__ */ new Error(`Errors while parsing ${entryPath}:`);
+		error.cause = parsed.errors;
+		throw error;
+	}
+	const resolveOptions = {
+		...entry.resolve,
+		from: pathToFileURL(entryPath),
+		extensions: entry.resolve?.extensions ?? [
+			".ts",
+			".js",
+			".mjs",
+			".cjs",
+			".json"
+		],
+		suffixes: entry.resolve?.suffixes ?? ["", "/index"]
+	};
+	const magicString = new MagicString(sourceText);
+	const updatedStarts = /* @__PURE__ */ new Set();
+	const rewriteSpecifier = (req) => {
+		let moduleId = req.value;
+		let wasAliasResolved = false;
+		if (entry.alias) {
+			for (const [alias, target] of Object.entries(entry.alias)) if (moduleId === alias || moduleId.startsWith(`${alias}/`)) {
+				moduleId = moduleId.replace(alias, target);
+				wasAliasResolved = true;
+				break;
+			}
+		}
+		if (!moduleId.startsWith(".") && !wasAliasResolved) return;
+		if (updatedStarts.has(req.start)) return;
+		updatedStarts.add(req.start);
+		const resolvedAbsolute = resolveModulePath(moduleId, resolveOptions);
+		const newId = relative(dirname(entryPath), resolvedAbsolute.replace(/\.ts$/, ".mjs"));
+		magicString.remove(req.start, req.end);
+		magicString.prependLeft(req.start, JSON.stringify(newId.startsWith(".") ? newId : `./${newId}`));
+	};
+	for (const staticImport of parsed.module.staticImports) rewriteSpecifier(staticImport.moduleRequest);
+	for (const staticExport of parsed.module.staticExports) for (const staticExportEntry of staticExport.entries) if (staticExportEntry.moduleRequest) rewriteSpecifier(staticExportEntry.moduleRequest);
+	sourceText = magicString.toString();
+	const transformed = transform(entryPath, sourceText, {
+		...entry.oxc,
+		...sourceOptions,
+		cwd: dirname(entryPath),
+		target: entry.target || "es2022",
+		typescript: {
+			declaration: { stripInternal: true },
+			...entry.oxc?.typescript
+		}
+	});
+	const transformErrors = transformed.errors.filter((err) => !err.message.includes("--isolatedDeclarations"));
+	if (transformErrors.length > 0) {
+		await writeFile("build-dump.ts", `/** Error dump for ${entryPath} */\n\n${sourceText}`, "utf8");
+		const error = /* @__PURE__ */ new Error(`Errors while transforming ${entryPath}: (hint: check build-dump.ts)`);
+		error.cause = transformErrors;
+		throw error;
+	}
+	if (entry.minify) {
+		const res = minify(entryPath, transformed.code, entry.minify === true ? {} : entry.minify);
+		transformed.code = res.code;
+		transformed.map = res.map;
+	}
+	const banner = resolveChunkAddon(entry.banner, "esm");
+	const footer = resolveChunkAddon(entry.footer, "esm");
+	transformed.code = addBannerFooter(transformed.code, banner, footer);
+	if (entry.nodeProtocol) transformed.code = transformNodeProtocol(transformed.code, entry.nodeProtocol);
+	return transformed;
+}
+
+//#endregion
+//#region src/features/exports.ts
+/**
+* Generate package.json exports field based on build configuration
+*/
+async function generatePackageExports(packageRoot, buildConfig, exportsConfig = { enabled: true }) {
+	if (!exportsConfig.enabled) return {};
+	const exports = {};
+	const baseDir = exportsConfig.baseDir || "dist";
+	if (exportsConfig.custom) Object.assign(exports, exportsConfig.custom);
+	if (buildConfig.entries) for (const entry of buildConfig.entries) {
+		const exportEntries = await generateExportFromEntry(packageRoot, entry, baseDir, exportsConfig.includeTypes);
+		for (const exportEntry of exportEntries) exports[exportEntry.key] = createExportValue(exportEntry);
+	}
+	if (!exports["."] && !exports["./index"]) {
+		const mainExport = await findMainExport(packageRoot, baseDir);
+		if (mainExport) exports["."] = mainExport;
+	}
+	return exports;
+}
+/**
+* Generate export entries from a build entry
+*/
+async function generateExportFromEntry(packageRoot, entry, baseDir, includeTypes) {
+	const exports = [];
+	if (entry.type === "bundle") {
+		const exportKey = getExportKey(entry.input);
+		const exportEntry = { key: exportKey };
+		if (Array.isArray(entry.format)) for (const format of entry.format) {
+			const outputPath = getOutputPath(entry, format, baseDir);
+			assignFormatToExport(exportEntry, format, outputPath);
+		}
+		else if (entry.format) {
+			const outputPath = getOutputPath(entry, entry.format, baseDir);
+			assignFormatToExport(exportEntry, entry.format, outputPath);
+		}
+		if (includeTypes && entry.dts) {
+			const typesPath = getTypesPath(entry, baseDir);
+			exportEntry.types = typesPath;
+		}
+		exports.push(exportEntry);
+	} else if (entry.type === "transform") {
+		const transformExports = await discoverTransformExports(packageRoot, entry, baseDir, includeTypes);
+		exports.push(...transformExports);
+	}
+	return exports;
+}
+/**
+* Get export key from input path
+*/
+function getExportKey(input) {
+	if (input === "index.ts" || input === "src/index.ts") return ".";
+	let key = input.replace(/\.(ts|js|tsx|jsx)$/, "");
+	key = key.replace(/^src\//, "");
+	return key === "index" ? "." : `./${key}`;
+}
+/**
+* Get output path for a specific format
+*/
+function getOutputPath(entry, format, baseDir) {
+	const extension = getExtensionForFormat(format);
+	const basename$1 = getBasename(entry.input);
+	if (format === "cjs") return `./${baseDir}/cjs/${basename$1}${extension}`;
+	else if (format === "esm") return `./${baseDir}/${basename$1}${extension}`;
+	else return `./${baseDir}/${format}/${basename$1}${extension}`;
+}
+/**
+* Get file extension for format
+*/
+function getExtensionForFormat(format) {
+	switch (format) {
+		case "esm": return ".mjs";
+		case "cjs": return ".cjs";
+		case "iife":
+		case "umd": return ".js";
+		default: return ".js";
+	}
+}
+/**
+* Get basename from input path
+*/
+function getBasename(input) {
+	return input.replace(/\.(ts|js|tsx|jsx)$/, "").replace(/^src\//, "");
+}
+/**
+* Get types path for entry
+*/
+function getTypesPath(entry, baseDir) {
+	const basename$1 = getBasename(entry.input);
+	return `./${baseDir}/${basename$1}.d.ts`;
+}
+/**
+* Assign format-specific path to export entry
+*/
+function assignFormatToExport(exportEntry, format, path) {
+	switch (format) {
+		case "esm":
+			exportEntry.import = path;
+			break;
+		case "cjs":
+			exportEntry.require = path;
+			break;
+		default:
+			exportEntry.import = path;
+			break;
+	}
+}
+/**
+* Create export value from export entry
+*/
+function createExportValue(entry) {
+	const value = {};
+	if (entry.types) value.types = entry.types;
+	if (entry.import) value.import = entry.import;
+	if (entry.require) value.require = entry.require;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && !entry.types) return value[keys[0]];
+	return value;
+}
+/**
+* Discover exports from transform entries
+*/
+async function discoverTransformExports(packageRoot, entry, baseDir, includeTypes) {
+	const exports = [];
+	const exportKey = getExportKey(entry.input);
+	const exportEntry = {
+		key: exportKey,
+		import: `./${baseDir}/${getBasename(entry.input)}.mjs`
+	};
+	if (includeTypes && entry.dts) exportEntry.types = getTypesPath(entry, baseDir);
+	exports.push(exportEntry);
+	return exports;
+}
+/**
+* Find main export file
+*/
+async function findMainExport(packageRoot, baseDir) {
+	const possibleMains = [
+		"index.mjs",
+		"index.js",
+		"index.cjs"
+	];
+	for (const main of possibleMains) try {
+		join(packageRoot, baseDir, main);
+		const value = {};
+		if (main.endsWith(".mjs")) value.import = `./${baseDir}/${main}`;
+		else if (main.endsWith(".cjs")) value.require = `./${baseDir}/${main}`;
+		else value.import = `./${baseDir}/${main}`;
+		return value;
+	} catch {
+		continue;
+	}
+	return null;
+}
+/**
+* Update package.json with generated exports
+*/
+async function updatePackageJsonExports(packageRoot, exports) {
+	const packageJsonPath = join(packageRoot, "package.json");
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		packageJson.exports = exports;
+		const updatedContent = `${JSON.stringify(packageJson, null, 2)}\n`;
+		await writeFile(packageJsonPath, updatedContent, "utf-8");
+	} catch (error) {
+		throw new Error(`Failed to update package.json: ${error}`);
+	}
+}
+
+//#endregion
+//#region src/features/logger.ts
+/**
+* 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);
+/**
+* Execute onSuccess callback after successful build
+*/
+async function executeOnSuccess(onSuccess, result, cwd) {
+	if (!onSuccess) return;
+	try {
+		if (typeof onSuccess === "string") {
+			logger.verbose(`Executing onSuccess command: ${onSuccess}`);
+			const { stdout, stderr } = await execAsync(onSuccess, { cwd });
+			if (stdout) logger.verbose(`onSuccess stdout: ${stdout.trim()}`);
+			if (stderr) logger.warn(`onSuccess stderr: ${stderr.trim()}`);
+		} else {
+			logger.verbose("Executing onSuccess callback function");
+			await onSuccess(result);
+		}
+		logger.verbose("onSuccess callback completed successfully");
+	} catch (error) {
+		logger.error("onSuccess callback failed:", error);
+		throw error;
+	}
+}
+/**
+* Create build result object
+*/
+function createBuildResult(entries, startTime) {
+	return {
+		entries: entries.map((entry) => ({
+			...entry,
+			format: entry.format
+		})),
+		duration: Date.now() - startTime
+	};
+}
+
+//#endregion
+//#region src/features/vite-config.ts
+/**
+* Load Vite configuration and convert to robuild config
+*/
+async function loadViteConfig(cwd) {
+	const configFiles = [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mts",
+		"vite.config.mjs",
+		"vitest.config.ts",
+		"vitest.config.js"
+	];
+	let configPath;
+	for (const file of configFiles) {
+		const fullPath = resolve(cwd, file);
+		if (existsSync(fullPath)) {
+			configPath = fullPath;
+			break;
+		}
+	}
+	if (!configPath) {
+		logger.warn("No Vite config file found, skipping Vite config loading");
+		return {};
+	}
+	try {
+		logger.verbose(`Loading Vite config from: ${configPath}`);
+		const configModule = await import(configPath);
+		const viteConfig = configModule.default || configModule;
+		return convertViteConfig(viteConfig);
+	} catch (error) {
+		logger.error(`Failed to load Vite config from ${configPath}:`, error);
+		return {};
+	}
+}
+/**
+* Convert Vite config to robuild config
+*/
+function convertViteConfig(viteConfig) {
+	const config = {};
+	if (viteConfig.build?.lib) {
+		const lib = viteConfig.build.lib;
+		const entries = [];
+		if (typeof lib.entry === "string") entries.push({
+			type: "bundle",
+			input: lib.entry,
+			format: convertFormats(lib.formats),
+			globalName: lib.name,
+			minify: viteConfig.build.minify,
+			target: convertTarget(viteConfig.build.target),
+			external: convertExternal(viteConfig.build.rollupOptions?.external)
+		});
+		else if (Array.isArray(lib.entry)) for (const entry of lib.entry) entries.push({
+			type: "bundle",
+			input: entry,
+			format: convertFormats(lib.formats),
+			globalName: lib.name,
+			minify: viteConfig.build.minify,
+			target: convertTarget(viteConfig.build.target),
+			external: convertExternal(viteConfig.build.rollupOptions?.external)
+		});
+		else if (lib.entry && typeof lib.entry === "object") for (const [name, entry] of Object.entries(lib.entry)) entries.push({
+			type: "bundle",
+			input: entry,
+			format: convertFormats(lib.formats),
+			globalName: lib.name || name,
+			minify: viteConfig.build.minify,
+			target: convertTarget(viteConfig.build.target),
+			external: convertExternal(viteConfig.build.rollupOptions?.external)
+		});
+		if (entries.length > 0) config.entries = entries;
+	}
+	return config;
+}
+/**
+* Convert Vite formats to robuild formats
+*/
+function convertFormats(formats) {
+	if (!formats) return void 0;
+	const formatMap = {
+		es: "esm",
+		cjs: "cjs",
+		umd: "umd",
+		iife: "iife"
+	};
+	return formats.map((format) => formatMap[format] || format).filter(Boolean);
+}
+/**
+* Convert Vite target to robuild target
+*/
+function convertTarget(target) {
+	if (!target) return void 0;
+	const targetMap = {
+		es2015: "es2015",
+		es2016: "es2016",
+		es2017: "es2017",
+		es2018: "es2018",
+		es2019: "es2019",
+		es2020: "es2020",
+		es2021: "es2021",
+		es2022: "es2022",
+		esnext: "esnext"
+	};
+	return targetMap[target] || void 0;
+}
+/**
+* Convert Vite external config to robuild external
+*/
+function convertExternal(external) {
+	return external;
+}
+
+//#endregion
+//#region src/features/workspace.ts
+/**
+* Discover workspace packages based on patterns
+*/
+async function discoverWorkspacePackages(workspaceRoot, patterns = ["packages/*", "apps/*"]) {
+	const packages = [];
+	for (const pattern of patterns) {
+		const packagePaths = await glob(pattern, {
+			cwd: workspaceRoot,
+			onlyDirectories: true
+		});
+		for (const packagePath of packagePaths) {
+			const fullPath = resolve(workspaceRoot, packagePath);
+			const packageJsonPath = join(fullPath, "package.json");
+			try {
+				const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+				const packageJson = JSON.parse(packageJsonContent);
+				packages.push({
+					name: packageJson.name || packagePath,
+					path: fullPath,
+					packageJson
+				});
+			} catch {
+				continue;
+			}
+		}
+	}
+	return packages;
+}
+/**
+* Filter workspace packages based on filter patterns
+*/
+function filterWorkspacePackages(packages, filter, exclude) {
+	let filtered = packages;
+	if (filter) {
+		const filters = Array.isArray(filter) ? filter : [filter];
+		filtered = filtered.filter((pkg) => filters.some((f) => matchesPattern(pkg.name, f) || matchesPattern(pkg.path, f)));
+	}
+	if (exclude) {
+		const excludes = Array.isArray(exclude) ? exclude : [exclude];
+		filtered = filtered.filter((pkg) => !excludes.some((e) => matchesPattern(pkg.name, e) || matchesPattern(pkg.path, e)));
+	}
+	return filtered;
+}
+/**
+* Check if a string matches a pattern (supports wildcards)
+*/
+function matchesPattern(str, pattern) {
+	const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\[([^\]]+)\]/g, "[$1]");
+	const regex = /* @__PURE__ */ new RegExp(`^${regexPattern}$`);
+	return regex.test(str);
+}
+/**
+* Load workspace configuration from package.json or workspace config file
+*/
+async function loadWorkspaceConfig(workspaceRoot) {
+	try {
+		const packageJsonPath = join(workspaceRoot, "package.json");
+		const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(packageJsonContent);
+		if (packageJson.workspaces) {
+			const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || [];
+			return { packages: workspaces };
+		}
+		try {
+			const { load } = await import("js-yaml");
+			const pnpmWorkspacePath = join(workspaceRoot, "pnpm-workspace.yaml");
+			const pnpmWorkspaceContent = await readFile(pnpmWorkspacePath, "utf-8");
+			const pnpmWorkspace = load(pnpmWorkspaceContent);
+			if (pnpmWorkspace?.packages) return { packages: pnpmWorkspace.packages };
+		} catch {}
+		try {
+			const lernaJsonPath = join(workspaceRoot, "lerna.json");
+			const lernaJsonContent = await readFile(lernaJsonPath, "utf-8");
+			const lernaJson = JSON.parse(lernaJsonContent);
+			if (lernaJson.packages) return { packages: lernaJson.packages };
+		} catch {}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Build workspace packages in dependency order
+*/
+async function buildWorkspacePackages(packages, buildFn) {
+	await Promise.all(packages.map(buildFn));
+}
+
+//#endregion
+//#region src/features/ignore-watch.ts
+/**
+* Normalize ignore patterns
+*/
+function normalizeIgnorePatterns(patterns) {
+	return patterns.map((pattern) => {
+		if (pattern.startsWith("./")) return pattern.slice(2);
+		if (pattern.startsWith("/")) return pattern.slice(1);
+		return pattern;
+	});
+}
+
+//#endregion
+//#region src/watch.ts
+/**
+* Start watching files and rebuild on changes
+*/
+async function startWatch(config, ctx, buildFn) {
+	const watchOptions = config.watch || {};
+	if (!watchOptions.enabled) throw new Error("Watch mode is not enabled");
+	const watchCtx = {
+		config,
+		ctx,
+		buildFn,
+		isBuilding: false,
+		pendingRebuild: false
+	};
+	const watchPatterns = await getWatchPatterns(config, ctx, watchOptions);
+	const ignorePatterns = getIgnorePatterns(config, watchOptions);
+	consola.info(`👀 Starting watch mode...`);
+	consola.info(`📁 Watching: ${colors.dim(watchPatterns.join(", "))}`);
+	if (ignorePatterns.length > 0) consola.info(`🚫 Ignoring: ${colors.dim(ignorePatterns.join(", "))}`);
+	const delay = watchOptions.delay ?? 100;
+	if (delay > 0) consola.info(`⏱️  Rebuild delay: ${colors.dim(`${delay}ms`)}`);
+	const watcher = watch(watchPatterns, {
+		ignored: ignorePatterns,
+		ignoreInitial: watchOptions.ignoreInitial ?? false,
+		persistent: true,
+		followSymlinks: false,
+		cwd: ctx.pkgDir
+	});
+	watcher.on("change", (path) => handleFileChange(watchCtx, path, "changed"));
+	watcher.on("add", (path) => {
+		if (watchOptions.watchNewFiles !== false) handleFileChange(watchCtx, path, "added");
+	});
+	watcher.on("unlink", (path) => handleFileChange(watchCtx, path, "removed"));
+	watcher.on("error", (error) => {
+		consola.error("❌ Watch error:", error);
+	});
+	if (process.env.DEBUG) {
+		watcher.on("addDir", (path) => consola.debug(`📁 Directory added: ${path}`));
+		watcher.on("unlinkDir", (path) => consola.debug(`📁 Directory removed: ${path}`));
+	}
+	await new Promise((resolve$1) => {
+		watcher.on("ready", () => {
+			const watchedPaths = watcher.getWatched();
+			const totalFiles = Object.values(watchedPaths).reduce((sum, files) => sum + files.length, 0);
+			consola.success(`🚀 Watch mode ready - watching ${totalFiles} files`);
+			consola.info(`💡 Press ${colors.cyan("Ctrl+C")} to stop watching`);
+			resolve$1();
+		});
+	});
+	return () => {
+		if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
+		return watcher.close();
+	};
+}
+/**
+* Handle file change events
+*/
+function handleFileChange(watchCtx, filePath, changeType) {
+	const { config, ctx } = watchCtx;
+	const watchOptions = config.watch || {};
+	const delay = watchOptions.delay ?? 100;
+	const relativePath = relative(ctx.pkgDir, join(ctx.pkgDir, filePath));
+	const formattedPath = fmtPath(relativePath);
+	const changeIcon = changeType === "changed" ? "📝" : changeType === "added" ? "➕" : "➖";
+	consola.info(`${changeIcon} ${colors.cyan(formattedPath)} ${changeType}`);
+	if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
+	watchCtx.pendingRebuild = true;
+	watchCtx.rebuildTimer = setTimeout(() => {
+		triggerRebuild(watchCtx);
+	}, delay);
+}
+/**
+* Trigger a rebuild
+*/
+async function triggerRebuild(watchCtx) {
+	const { config, buildFn } = watchCtx;
+	if (watchCtx.isBuilding) return;
+	if (!watchCtx.pendingRebuild) return;
+	watchCtx.isBuilding = true;
+	watchCtx.pendingRebuild = false;
+	try {
+		consola.info(`🔄 Rebuilding...`);
+		const start = Date.now();
+		const buildConfig = {
+			...config,
+			watch: {
+				...config.watch,
+				enabled: false
+			}
+		};
+		await buildFn(buildConfig);
+		const duration = Date.now() - start;
+		consola.success(`✅ Rebuild completed in ${duration}ms`);
+	} catch (error) {
+		consola.error("❌ Rebuild failed:");
+		if (error instanceof Error) {
+			consola.error(`   ${error.message}`);
+			if (process.env.DEBUG && error.stack) consola.debug(error.stack);
+		} else consola.error(`   ${String(error)}`);
+		consola.info("👀 Still watching for changes...");
+	} finally {
+		watchCtx.isBuilding = false;
+		if (watchCtx.pendingRebuild) setTimeout(() => triggerRebuild(watchCtx), watchCtx.config.watch?.delay ?? 100);
+	}
+}
+/**
+* Get patterns for files to watch
+*/
+async function getWatchPatterns(config, ctx, watchOptions) {
+	if (watchOptions.include && watchOptions.include.length > 0) return watchOptions.include.map(normalizeGlobPattern);
+	const patterns = /* @__PURE__ */ new Set();
+	const addPattern = (pattern) => {
+		if (!pattern) return;
+		patterns.add(normalizeGlobPattern(pattern));
+	};
+	const addFilePatterns = (inputFile) => {
+		const absoluteInput = resolveToAbsolute(inputFile, ctx);
+		const filePattern = normalizeRelativeToPkg(absoluteInput, ctx);
+		if (filePattern && filePattern !== ".") addPattern(filePattern);
+		addPattern(getDirGlobPattern(dirname(absoluteInput), ctx));
+	};
+	const addDirectoryPatterns = (inputDir) => {
+		const absoluteDir = resolveToAbsolute(inputDir, ctx);
+		addPattern(getDirGlobPattern(absoluteDir, ctx));
+	};
+	for (const entry of config.entries || []) if (typeof entry === "string") {
+		const [input] = entry.split(":");
+		if (input.endsWith("/")) addDirectoryPatterns(input);
+		else {
+			const inputs = input.split(",");
+			for (const inputFile of inputs) addFilePatterns(inputFile);
+		}
+	} else if (entry.type === "transform") addDirectoryPatterns(entry.input);
+	else {
+		const inputs = Array.isArray(entry.input) ? entry.input : [entry.input];
+		for (const inputFile of inputs) addFilePatterns(inputFile);
+	}
+	if (patterns.size === 0) [
+		"src/**/*",
+		"*.ts",
+		"*.js",
+		"*.mjs",
+		"*.json"
+	].forEach((pattern) => addPattern(pattern));
+	return Array.from(patterns);
+}
+/**
+* Get patterns for files to ignore
+*/
+function getIgnorePatterns(config, watchOptions) {
+	const defaultIgnores = [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/coverage/**",
+		"**/.git/**",
+		"**/.DS_Store",
+		"**/Thumbs.db",
+		"**/*.log",
+		"**/tmp/**",
+		"**/temp/**"
+	];
+	const allIgnores = [...defaultIgnores];
+	if (watchOptions.exclude && watchOptions.exclude.length > 0) allIgnores.push(...watchOptions.exclude);
+	if (config.ignoreWatch && config.ignoreWatch.length > 0) allIgnores.push(...normalizeIgnorePatterns(config.ignoreWatch));
+	return allIgnores;
+}
+function resolveToAbsolute(path, ctx) {
+	return isAbsolute(path) ? path : join(ctx.pkgDir, path);
+}
+function normalizeGlobPattern(pattern) {
+	return pattern.replace(/\\/g, "/");
+}
+function normalizeRelativeToPkg(target, ctx) {
+	const relativePath = relative(ctx.pkgDir, target);
+	if (!relativePath || relativePath === "") return ".";
+	if (relativePath.includes(":")) return normalizeGlobPattern(target);
+	return normalizeGlobPattern(relativePath);
+}
+function getDirGlobPattern(directory, ctx) {
+	const normalizedDir = normalizeRelativeToPkg(directory, ctx);
+	if (!normalizedDir || normalizedDir === "." || normalizedDir === "./") return "**/*";
+	return `${stripTrailingSlash(normalizedDir)}/**/*`;
+}
+function stripTrailingSlash(path) {
+	return path.replace(/\/+$/, "");
+}
+
+//#endregion
+//#region src/build.ts
+/**
+* Build dist/ from src/
+*/
+async function build(config) {
+	const startTime = Date.now();
+	if (config.logLevel) configureLogger(config.logLevel);
+	resetLogCounts();
+	const pkgDir = normalizePath(config.cwd);
+	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
+	const ctx = {
+		pkg,
+		pkgDir
+	};
+	if (config.workspace) return buildWorkspace(config, pkgDir);
+	let finalConfig = config;
+	if (config.fromVite) {
+		logger.verbose("Loading configuration from Vite config file");
+		const viteConfig = await loadViteConfig(pkgDir);
+		finalConfig = {
+			...viteConfig,
+			...config
+		};
+	}
+	if (finalConfig.watch?.enabled) {
+		logger.info(`👀 Starting watch mode for \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+		await performBuild(finalConfig, ctx, startTime);
+		const stopWatch = await startWatch(finalConfig, ctx, build);
+		const cleanup = () => {
+			consola.info("🛑 Stopping watch mode...");
+			stopWatch();
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		return new Promise(() => {});
+	}
+	logger.info(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+	await performBuild(finalConfig, ctx, startTime);
+}
+/**
+* Perform the actual build process
+*/
+async function performBuild(config, ctx, startTime) {
+	const start = Date.now();
+	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;
+		if (!entry.input) throw new Error(`Build entry missing \`input\`: ${JSON.stringify(entry, null, 2)}`);
+		entry = { ...entry };
+		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
+		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, ctx.pkgDir)) : normalizePath(entry.input, ctx.pkgDir);
+		return entry;
+	});
+	await hooks.entries?.(entries, ctx);
+	const outDirs = [];
+	for (const outDir of entries.map((e) => e.outDir).sort()) if (!outDirs.some((dir) => outDir.startsWith(dir))) outDirs.push(outDir);
+	for (const entry of entries) await (entry.type === "bundle" ? rolldownBuild(ctx, entry, hooks, config) : transformDir(ctx, entry));
+	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)`));
+	const duration = Date.now() - start;
+	logger.success(`\n✅ robuild finished in ${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 || ".");
+}
+/**
+* Build workspace packages
+*/
+async function buildWorkspace(config, workspaceRoot) {
+	logger.info("🏢 Building workspace packages...");
+	const workspaceConfig = await loadWorkspaceConfig(workspaceRoot);
+	if (!workspaceConfig) throw new Error("No workspace configuration found");
+	const allPackages = await discoverWorkspacePackages(workspaceRoot, workspaceConfig.packages);
+	if (allPackages.length === 0) {
+		logger.warn("No packages found in workspace");
+		return;
+	}
+	const filteredPackages = filterWorkspacePackages(allPackages, config.filter || config.workspace?.filter, config.workspace?.exclude);
+	if (filteredPackages.length === 0) {
+		logger.warn("No packages match the filter criteria");
+		return;
+	}
+	logger.info(`Building ${filteredPackages.length} packages`);
+	const buildPackage = async (pkg) => {
+		logger.info(`📦 Building ${pkg.name}...`);
+		try {
+			const packageConfig = {
+				...config,
+				cwd: pkg.path,
+				workspace: void 0
+			};
+			await build(packageConfig);
+			if (config.exports?.enabled) {
+				const exportsConfig = {
+					enabled: true,
+					...config.exports
+				};
+				const exports = await generatePackageExports(pkg.path, packageConfig, exportsConfig);
+				if (config.exports.autoUpdate) {
+					await updatePackageJsonExports(pkg.path, exports);
+					logger.info(`Updated exports for ${pkg.name}`);
+				}
+			}
+			logger.success(`Built ${pkg.name}`);
+		} catch (error) {
+			logger.error(`Failed to build ${pkg.name}:`, error);
+			throw error;
+		}
+	};
+	await buildWorkspacePackages(filteredPackages, buildPackage);
+	logger.success(`Successfully built ${filteredPackages.length} packages`);
+}
+function readJSON(specifier) {
+	return import(specifier, { with: { type: "json" } }).then((r) => r.default);
+}
+
+//#endregion
+export { build };