robuild 0.0.13 → 0.0.14

package/README.md

@@ -21,7 +21,7 @@ English | <a href="./README-zh.md">简体中文</a>
 🎯 **TypeScript**: First-class TypeScript support with `.d.ts` generation
 🔄 **Dual mode**: Bundle or transform your source code
 🚀 **Stub mode**: Lightning-fast development with file linking
-🏢 **Enterprise**: Workspace support, package filtering, migration tools
+📤 **Exports**: Automatic package.json exports generation
 
 ## Installation
 

package/dist/_chunks/build-Ck2ABQml.mjs

@@ -0,0 +1,3 @@
+import { build, performBuild } from "./build-Dtx2Wt3D.mjs";
+
+export { performBuild };

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

@@ -1,14 +1,14 @@
 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 { consola } from "consola";
 import { defu } from "defu";
 import { resolveModulePath } from "exsolve";
 import { parseSync } from "oxc-parser";
-import { rolldown } from "rolldown";
+import { rolldown, watch } from "rolldown";
 import { dts } from "rolldown-plugin-dts";
 import { existsSync, promises, readdirSync, statSync } from "node:fs";
 import { glob } from "glob";
@@ -20,8 +20,6 @@ import { transform } from "oxc-transform";
 import { glob as glob$1 } from "tinyglobby";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import { watch } from "chokidar";
-import "minimatch";
 
 //#region src/features/advanced-build.ts
 /**
@@ -39,9 +37,10 @@ function createSkipNodeModulesPlugin(options) {
 	};
 	return {
 		name: "skip-node-modules",
-		resolveId: async (id) => {
+		resolveId: async (id, importer) => {
 			if (shouldInline(id)) return null;
-			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/")) return {
+			if (!importer) return null;
+			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\\")) return {
 				id,
 				external: true
 			};
@@ -53,7 +52,7 @@ function createSkipNodeModulesPlugin(options) {
 * Unbundle mode: preserve file structure without bundling
 */
 async function unbundleTransform(ctx, entry) {
-	const inputDir = join(ctx.pkgDir, entry.input);
+	const inputDir = isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input);
 	const outputDir = join(ctx.pkgDir, entry.outDir || "dist");
 	await processDirectoryUnbundled(inputDir, outputDir, entry);
 }
@@ -101,7 +100,7 @@ async function processFileUnbundled(inputPath, outputPath, entry) {
 /**
 * Transform imports for unbundle mode
 */
-function transformImportsForUnbundle(content, filePath, entry) {
+function transformImportsForUnbundle(content, _filePath, entry) {
 	let transformedContent = content;
 	transformedContent = transformedContent.replace(/from\s+['"]([^'"]+)['"]/g, (match, importPath) => {
 		if (importPath.startsWith(".")) {
@@ -231,11 +230,11 @@ function createGlobImportPlugin(options = {}) {
 			let transformedCode = code;
 			while ((match = globImportRegex.exec(code)) !== null) {
 				hasGlobImports = true;
-				const [fullMatch, quote, pattern, optionsStr] = match;
+				const [fullMatch, , pattern, optionsStr] = match;
 				let globOptions = {};
 				if (optionsStr) try {
 					globOptions = parseGlobOptions(optionsStr);
-				} catch (error) {
+				} catch {
 					console.warn("Failed to parse glob options:", optionsStr);
 				}
 				const isEager = globOptions.eager ?? eager;
@@ -261,7 +260,7 @@ async function generateGlobImport(pattern, importer, eager, asUrls, allowedPatte
 	try {
 		const absolutePattern = resolve(importerDir, pattern);
 		files = await glob(absolutePattern, { ignore: ["**/node_modules/**", "**/.git/**"] });
-	} catch (error) {
+	} catch {
 		if (pattern.includes("*.js")) files = [resolve(importerDir, pattern.replace("*", "module1")), resolve(importerDir, pattern.replace("*", "module2"))];
 	}
 	if (eager) return generateEagerImport(files, importerDir, asUrls);
@@ -345,7 +344,7 @@ function addHashToFilename(filename, content, hashLength = 8) {
 * Check if filename already has hash
 */
 function hasHash(filename) {
-	return /-[a-f0-9]{8}(\.|$)/.test(filename);
+	return /-[a-f0-9]{8}(?:\.|$)/.test(filename);
 }
 
 //#endregion
@@ -411,7 +410,12 @@ async function transformWithLoader(filePath, content, loader, options) {
 		case "jsx":
 		case "ts":
 		case "tsx": return content;
-		case "json": return `export default ${content}`;
+		case "json": try {
+			const parsed = JSON.parse(content);
+			return `export default ${JSON.stringify(parsed)}`;
+		} catch {
+			return `export default ${JSON.stringify(content)}`;
+		}
 		case "css": return transformCssContent(content, options);
 		case "text": return `export default ${JSON.stringify(content)}`;
 		case "file": return transformFileContent(filePath, options);
@@ -447,7 +451,7 @@ function transformFileContent(filePath, options) {
 /**
 * Transform file content to data URL
 */
-function transformDataUrlContent(filePath, content, options) {
+function transformDataUrlContent(filePath, content, _options) {
 	const ext = extname(filePath).toLowerCase();
 	const mimeType = getMimeType(ext);
 	const base64 = Buffer.from(content).toString("base64");
@@ -457,7 +461,7 @@ function transformDataUrlContent(filePath, content, options) {
 /**
 * Transform binary file content
 */
-function transformBinaryContent(filePath, options) {
+function transformBinaryContent(filePath, _options) {
 	const fileName = filePath.split("/").pop() || "binary";
 	return `export default ${JSON.stringify(fileName)}`;
 }
@@ -467,7 +471,7 @@ function transformBinaryContent(filePath, options) {
 function extractCssClassNames(content) {
 	const classRegex = /\.([a-z_-][\w-]*)/gi;
 	const matches = content.match(classRegex) || [];
-	return [...new Set(matches.map((match) => match.slice(1)))];
+	return Array.from(new Set(matches.map((match) => match.slice(1))));
 }
 /**
 * Get MIME type for file extension
@@ -508,13 +512,15 @@ function createLoaderPlugin(loaders) {
 	return {
 		name: "loaders",
 		load: async (id) => {
+			const ext = extname(id);
 			const loader = getLoaderForFile(id, loaders);
 			if (loader === "js" || loader === "jsx" || loader === "ts" || loader === "tsx") return null;
+			if (loader === "json" && !loaders?.[ext]) return null;
 			try {
 				const content = await readFile(id, "utf-8");
-				const options = loaders?.[extname(id)]?.options;
+				const options = loaders?.[ext]?.options;
 				return await transformWithLoader(id, content, loader, options);
-			} catch (error) {
+			} catch {
 				return null;
 			}
 		}
@@ -742,7 +748,7 @@ function createShimsPlugin(config = true) {
 	return {
 		name: "shims",
 		transform: async (code, id) => {
-			if (!/\.(js|mjs|cjs|ts|mts|cts|jsx|tsx)$/.test(id)) return null;
+			if (!/\.(?:js|mjs|cjs|ts|mts|cts|jsx|tsx)$/.test(id)) return null;
 			const needs = detectShimNeeds(code);
 			if (!needs.needsDirname && !needs.needsRequire && !needs.needsExports && !needs.needsEnv) return null;
 			const transformedCode = transformWithShims(code, shimsConfig);
@@ -751,88 +757,6 @@ function createShimsPlugin(config = true) {
 	};
 }
 
-//#endregion
-//#region src/utils.ts
-function fmtPath(path) {
-	return resolve(path).replace(process.cwd(), ".");
-}
-function analyzeDir(dir) {
-	if (Array.isArray(dir)) {
-		let totalSize$1 = 0;
-		let totalFiles = 0;
-		for (const d of dir) {
-			const { size, files: files$1 } = analyzeDir(d);
-			totalSize$1 += size;
-			totalFiles += files$1;
-		}
-		return {
-			size: totalSize$1,
-			files: totalFiles
-		};
-	}
-	let totalSize = 0;
-	const files = readdirSync(dir, {
-		withFileTypes: true,
-		recursive: true
-	});
-	for (const file of files) {
-		const fullPath = join(file.parentPath, file.name);
-		if (file.isFile()) {
-			const { size } = statSync(fullPath);
-			totalSize += size;
-		}
-	}
-	return {
-		size: totalSize,
-		files: files.length
-	};
-}
-async function distSize(dir, entry) {
-	const build$1 = await rolldown({
-		input: join(dir, entry),
-		plugins: [],
-		platform: "neutral",
-		external: (id) => id[0] !== "." && !id.startsWith(dir)
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
-	const code = output[0].code;
-	const { code: minified } = await minify(entry, code);
-	return {
-		size: Buffer.byteLength(code),
-		minSize: Buffer.byteLength(minified),
-		minGzipSize: gzipSync(minified).length
-	};
-}
-async function sideEffectSize(dir, entry) {
-	const virtualEntry = {
-		name: "virtual-entry",
-		async resolveId(id, importer, opts) {
-			if (id === "#entry") return { id };
-			const resolved = await this.resolve(id, importer, opts);
-			if (!resolved) return null;
-			resolved.moduleSideEffects = null;
-			return resolved;
-		},
-		load(id) {
-			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
-		}
-	};
-	const build$1 = await rolldown({
-		input: "#entry",
-		platform: "neutral",
-		external: (id) => id[0] !== "." && !id.startsWith(dir),
-		plugins: [virtualEntry]
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
-	if (process.env.INSPECT_BUILD) {
-		console.log("---------[side effects]---------");
-		console.log(entry);
-		console.log(output[0].code);
-		console.log("-------------------------------");
-	}
-	return Buffer.byteLength(output[0].code.trim());
-}
-
 //#endregion
 //#region src/features/node-protocol.ts
 /**
@@ -925,7 +849,7 @@ function transformNodeProtocol(code, nodeProtocol) {
 }
 
 //#endregion
-//#region src/builders/plugins/node-protocol.ts
+//#region src/plugins/node-protocol.ts
 /**
 * Rolldown plugin for Node.js protocol handling
 */
@@ -943,7 +867,7 @@ function nodeProtocolPlugin(nodeProtocol) {
 }
 
 //#endregion
-//#region src/builders/plugins/shebang.ts
+//#region src/plugins/shebang.ts
 const SHEBANG_RE = /^#![^\n]*/;
 function shebangPlugin() {
 	return {
@@ -966,6 +890,88 @@ async function makeExecutable(filePath) {
 	await promises.chmod(filePath, 493).catch(() => {});
 }
 
+//#endregion
+//#region src/utils.ts
+function fmtPath(path) {
+	return resolve(path).replace(process.cwd(), ".");
+}
+function analyzeDir(dir) {
+	if (Array.isArray(dir)) {
+		let totalSize$1 = 0;
+		let totalFiles = 0;
+		for (const d of dir) {
+			const { size, files: files$1 } = analyzeDir(d);
+			totalSize$1 += size;
+			totalFiles += files$1;
+		}
+		return {
+			size: totalSize$1,
+			files: totalFiles
+		};
+	}
+	let totalSize = 0;
+	const files = readdirSync(dir, {
+		withFileTypes: true,
+		recursive: true
+	});
+	for (const file of files) {
+		const fullPath = join(file.parentPath, file.name);
+		if (file.isFile()) {
+			const { size } = statSync(fullPath);
+			totalSize += size;
+		}
+	}
+	return {
+		size: totalSize,
+		files: files.length
+	};
+}
+async function distSize(dir, entry) {
+	const build$1 = await rolldown({
+		input: join(dir, entry),
+		plugins: [],
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir)
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	const code = output[0].code;
+	const { code: minified } = minify(entry, code);
+	return {
+		size: Buffer.byteLength(code),
+		minSize: Buffer.byteLength(minified),
+		minGzipSize: gzipSync(minified).length
+	};
+}
+async function sideEffectSize(dir, entry) {
+	const virtualEntry = {
+		name: "virtual-entry",
+		async resolveId(id, importer, opts) {
+			if (id === "#entry") return { id };
+			const resolved = await this.resolve(id, importer, opts);
+			if (!resolved) return null;
+			resolved.moduleSideEffects = null;
+			return resolved;
+		},
+		load(id) {
+			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
+		}
+	};
+	const build$1 = await rolldown({
+		input: "#entry",
+		platform: "neutral",
+		external: (id) => id[0] !== "." && !id.startsWith(dir),
+		plugins: [virtualEntry]
+	});
+	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	if (process.env.INSPECT_BUILD) {
+		console.log("---------[side effects]---------");
+		console.log(entry);
+		console.log(output[0].code);
+		console.log("-------------------------------");
+	}
+	return Buffer.byteLength(output[0].code.trim());
+}
+
 //#endregion
 //#region src/builders/bundle.ts
 /**
@@ -1070,7 +1076,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			externalDeps = externalDeps.filter((dep) => {
 				if (typeof dep === "string") return !excludedNames.has(dep);
 				if (dep instanceof RegExp) {
-					for (const name of excludedNames) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
+					for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
 					return true;
 				}
 				return true;
@@ -1499,176 +1505,6 @@ async function transformModule(entryPath, entry) {
 	return transformed;
 }
 
-//#endregion
-//#region src/features/exports.ts
-/**
-* Generate package.json exports field based on build configuration
-*/
-async function generatePackageExports(packageRoot, buildConfig, exportsConfig = { enabled: true }) {
-	if (!exportsConfig.enabled) return {};
-	const exports = {};
-	const baseDir = exportsConfig.baseDir || "dist";
-	if (exportsConfig.custom) Object.assign(exports, exportsConfig.custom);
-	if (buildConfig.entries) for (const entry of buildConfig.entries) {
-		const exportEntries = await generateExportFromEntry(packageRoot, entry, baseDir, exportsConfig.includeTypes);
-		for (const exportEntry of exportEntries) exports[exportEntry.key] = createExportValue(exportEntry);
-	}
-	if (!exports["."] && !exports["./index"]) {
-		const mainExport = await findMainExport(packageRoot, baseDir);
-		if (mainExport) exports["."] = mainExport;
-	}
-	return exports;
-}
-/**
-* Generate export entries from a build entry
-*/
-async function generateExportFromEntry(packageRoot, entry, baseDir, includeTypes) {
-	const exports = [];
-	if (entry.type === "bundle") {
-		const exportKey = getExportKey(entry.input);
-		const exportEntry = { key: exportKey };
-		if (Array.isArray(entry.format)) for (const format of entry.format) {
-			const outputPath = getOutputPath(entry, format, baseDir);
-			assignFormatToExport(exportEntry, format, outputPath);
-		}
-		else if (entry.format) {
-			const outputPath = getOutputPath(entry, entry.format, baseDir);
-			assignFormatToExport(exportEntry, entry.format, outputPath);
-		}
-		if (includeTypes && entry.dts) {
-			const typesPath = getTypesPath(entry, baseDir);
-			exportEntry.types = typesPath;
-		}
-		exports.push(exportEntry);
-	} else if (entry.type === "transform") {
-		const transformExports = await discoverTransformExports(packageRoot, entry, baseDir, includeTypes);
-		exports.push(...transformExports);
-	}
-	return exports;
-}
-/**
-* Get export key from input path
-*/
-function getExportKey(input) {
-	if (input === "index.ts" || input === "src/index.ts") return ".";
-	let key = input.replace(/\.(ts|js|tsx|jsx)$/, "");
-	key = key.replace(/^src\//, "");
-	return key === "index" ? "." : `./${key}`;
-}
-/**
-* Get output path for a specific format
-*/
-function getOutputPath(entry, format, baseDir) {
-	const extension = getExtensionForFormat(format);
-	const basename$1 = getBasename(entry.input);
-	if (format === "cjs") return `./${baseDir}/cjs/${basename$1}${extension}`;
-	else if (format === "esm") return `./${baseDir}/${basename$1}${extension}`;
-	else return `./${baseDir}/${format}/${basename$1}${extension}`;
-}
-/**
-* Get file extension for format
-*/
-function getExtensionForFormat(format) {
-	switch (format) {
-		case "esm": return ".mjs";
-		case "cjs": return ".cjs";
-		case "iife":
-		case "umd": return ".js";
-		default: return ".js";
-	}
-}
-/**
-* Get basename from input path
-*/
-function getBasename(input) {
-	return input.replace(/\.(ts|js|tsx|jsx)$/, "").replace(/^src\//, "");
-}
-/**
-* Get types path for entry
-*/
-function getTypesPath(entry, baseDir) {
-	const basename$1 = getBasename(entry.input);
-	return `./${baseDir}/${basename$1}.d.ts`;
-}
-/**
-* Assign format-specific path to export entry
-*/
-function assignFormatToExport(exportEntry, format, path) {
-	switch (format) {
-		case "esm":
-			exportEntry.import = path;
-			break;
-		case "cjs":
-			exportEntry.require = path;
-			break;
-		default:
-			exportEntry.import = path;
-			break;
-	}
-}
-/**
-* Create export value from export entry
-*/
-function createExportValue(entry) {
-	const value = {};
-	if (entry.types) value.types = entry.types;
-	if (entry.import) value.import = entry.import;
-	if (entry.require) value.require = entry.require;
-	const keys = Object.keys(value);
-	if (keys.length === 1 && !entry.types) return value[keys[0]];
-	return value;
-}
-/**
-* Discover exports from transform entries
-*/
-async function discoverTransformExports(packageRoot, entry, baseDir, includeTypes) {
-	const exports = [];
-	const exportKey = getExportKey(entry.input);
-	const exportEntry = {
-		key: exportKey,
-		import: `./${baseDir}/${getBasename(entry.input)}.mjs`
-	};
-	if (includeTypes && entry.dts) exportEntry.types = getTypesPath(entry, baseDir);
-	exports.push(exportEntry);
-	return exports;
-}
-/**
-* Find main export file
-*/
-async function findMainExport(packageRoot, baseDir) {
-	const possibleMains = [
-		"index.mjs",
-		"index.js",
-		"index.cjs"
-	];
-	for (const main of possibleMains) try {
-		join(packageRoot, baseDir, main);
-		const value = {};
-		if (main.endsWith(".mjs")) value.import = `./${baseDir}/${main}`;
-		else if (main.endsWith(".cjs")) value.require = `./${baseDir}/${main}`;
-		else value.import = `./${baseDir}/${main}`;
-		return value;
-	} catch {
-		continue;
-	}
-	return null;
-}
-/**
-* Update package.json with generated exports
-*/
-async function updatePackageJsonExports(packageRoot, exports) {
-	const packageJsonPath = join(packageRoot, "package.json");
-	try {
-		const content = await readFile(packageJsonPath, "utf-8");
-		const packageJson = JSON.parse(content);
-		packageJson.exports = exports;
-		const updatedContent = `${JSON.stringify(packageJson, null, 2)}\n`;
-		await writeFile(packageJsonPath, updatedContent, "utf-8");
-	} catch (error) {
-		throw new Error(`Failed to update package.json: ${error}`);
-	}
-}
-
 //#endregion
 //#region src/features/logger.ts
 /**
@@ -1904,263 +1740,80 @@ function convertExternal(external) {
 }
 
 //#endregion
-//#region src/features/workspace.ts
-/**
-* Discover workspace packages based on patterns
-*/
-async function discoverWorkspacePackages(workspaceRoot, patterns = ["packages/*", "apps/*"]) {
-	const packages = [];
-	for (const pattern of patterns) {
-		const packagePaths = await glob(pattern, {
-			cwd: workspaceRoot,
-			onlyDirectories: true
-		});
-		for (const packagePath of packagePaths) {
-			const fullPath = resolve(workspaceRoot, packagePath);
-			const packageJsonPath = join(fullPath, "package.json");
-			try {
-				const packageJsonContent = await readFile(packageJsonPath, "utf-8");
-				const packageJson = JSON.parse(packageJsonContent);
-				packages.push({
-					name: packageJson.name || packagePath,
-					path: fullPath,
-					packageJson
-				});
-			} catch {
-				continue;
-			}
-		}
-	}
-	return packages;
-}
-/**
-* 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;
-	}
+//#region src/watch.ts
+function normalizePath$1(path, resolveFrom) {
+	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
 }
 /**
-* Build workspace packages in dependency order
+* Perform watch build using rolldown's built-in watch mode
 */
-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);
+async function performWatchBuild(config, ctx, startTime) {
+	const { performBuild: performBuild$1 } = await import("./build-Ck2ABQml.mjs");
+	await performBuild$1(config, ctx, startTime);
+	const bundleEntries = (config.entries || []).filter((entry) => {
+		if (typeof entry === "string") return !entry.endsWith("/");
+		return entry.type === "bundle";
 	});
-	if (process.env.DEBUG) {
-		watcher.on("addDir", (path) => consola.debug(`📁 Directory added: ${path}`));
-		watcher.on("unlinkDir", (path) => consola.debug(`📁 Directory removed: ${path}`));
+	if (bundleEntries.length > 0) await startRolldownWatch(ctx, bundleEntries);
+	else {
+		logger.warn("Transform-only watch mode not yet implemented with rolldown");
+		return new Promise(() => {});
 	}
-	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
+* Start rolldown watch mode for bundle entries
 */
-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
+async function startRolldownWatch(ctx, bundleEntries) {
+	logger.info("🚧 Using rolldown built-in watch mode...");
+	const watchConfigs = [];
+	for (const rawEntry of bundleEntries) {
+		let entry;
+		if (typeof rawEntry === "string") {
+			const [input, outDir] = rawEntry.split(":");
+			entry = {
+				type: "bundle",
+				input,
+				outDir: outDir || "dist"
+			};
+		} else entry = rawEntry;
+		entry.input = Array.isArray(entry.input) ? entry.input.map((i) => normalizePath$1(i, ctx.pkgDir)) : normalizePath$1(entry.input, ctx.pkgDir);
+		const watchConfig = {
+			input: Array.isArray(entry.input) ? entry.input[0] : entry.input,
+			output: {
+				dir: entry.outDir,
+				format: "esm"
 			}
 		};
-		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);
+		watchConfigs.push(watchConfig);
 	}
-}
-/**
-* Get patterns for files to watch
-*/
-async function getWatchPatterns(config, ctx, watchOptions) {
-	if (watchOptions.include && watchOptions.include.length > 0) return watchOptions.include;
-	const patterns = [];
-	for (const entry of config.entries || []) if (typeof entry === "string") {
-		const [input] = entry.split(":");
-		if (input.endsWith("/")) patterns.push(`${input}**/*`);
-		else {
-			const inputs = input.split(",");
-			for (const inputFile of inputs) {
-				patterns.push(inputFile);
-				const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
-				if (dir) patterns.push(`${dir}/**/*`);
-			}
-		}
-	} else if (entry.type === "transform") patterns.push(`${entry.input}/**/*`);
-	else {
-		const inputs = Array.isArray(entry.input) ? entry.input : [entry.input];
-		for (const inputFile of inputs) {
-			patterns.push(inputFile);
-			const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
-			if (dir) patterns.push(`${dir}/**/*`);
+	const watcher = watch(watchConfigs);
+	watcher.on("event", (event) => {
+		switch (event.code) {
+			case "START":
+				logger.info("🔄 Rebuilding...");
+				break;
+			case "BUNDLE_START":
+				logger.info("📦 Bundling...");
+				break;
+			case "BUNDLE_END":
+				logger.success("✅ Bundle complete");
+				break;
+			case "END":
+				logger.success("🎉 Watch rebuild complete");
+				break;
+			case "ERROR":
+				logger.error("❌ Build error:", event.error);
+				break;
 		}
-	}
-	if (patterns.length === 0) patterns.push("src/**/*", "*.ts", "*.js", "*.mjs", "*.json");
-	return [...new Set(patterns)];
-}
-/**
-* Get patterns for files to ignore
-*/
-function getIgnorePatterns(config, watchOptions) {
-	const defaultIgnores = [
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/build/**",
-		"**/coverage/**",
-		"**/.git/**",
-		"**/.DS_Store",
-		"**/Thumbs.db",
-		"**/*.log",
-		"**/tmp/**",
-		"**/temp/**"
-	];
-	const allIgnores = [...defaultIgnores];
-	if (watchOptions.exclude && watchOptions.exclude.length > 0) allIgnores.push(...watchOptions.exclude);
-	if (config.ignoreWatch && config.ignoreWatch.length > 0) allIgnores.push(...normalizeIgnorePatterns(config.ignoreWatch));
-	return allIgnores;
+	});
+	const cleanup = async () => {
+		consola.info("🛑 Stopping watch mode...");
+		await watcher.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+	return new Promise(() => {});
 }
 
 //#endregion
@@ -2178,7 +1831,6 @@ async function build(config) {
 		pkg,
 		pkgDir
 	};
-	if (config.workspace) return buildWorkspace(config, pkgDir);
 	let finalConfig = config;
 	if (config.fromVite) {
 		logger.verbose("Loading configuration from Vite config file");
@@ -2190,16 +1842,8 @@ async function build(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(() => {});
+		await performWatchBuild(finalConfig, ctx, startTime);
+		return;
 	}
 	logger.info(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
 	await performBuild(finalConfig, ctx, startTime);
@@ -2249,56 +1893,10 @@ async function performBuild(config, ctx, startTime) {
 function normalizePath(path, resolveFrom) {
 	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
 }
-/**
-* Build workspace packages
-*/
-async function buildWorkspace(config, workspaceRoot) {
-	logger.info("🏢 Building workspace packages...");
-	const workspaceConfig = await loadWorkspaceConfig(workspaceRoot);
-	if (!workspaceConfig) throw new Error("No workspace configuration found");
-	const allPackages = await discoverWorkspacePackages(workspaceRoot, workspaceConfig.packages);
-	if (allPackages.length === 0) {
-		logger.warn("No packages found in workspace");
-		return;
-	}
-	const filteredPackages = filterWorkspacePackages(allPackages, config.filter || config.workspace?.filter, config.workspace?.exclude);
-	if (filteredPackages.length === 0) {
-		logger.warn("No packages match the filter criteria");
-		return;
-	}
-	logger.info(`Building ${filteredPackages.length} packages`);
-	const buildPackage = async (pkg) => {
-		logger.info(`📦 Building ${pkg.name}...`);
-		try {
-			const packageConfig = {
-				...config,
-				cwd: pkg.path,
-				workspace: void 0
-			};
-			await build(packageConfig);
-			if (config.exports?.enabled) {
-				const exportsConfig = {
-					enabled: true,
-					...config.exports
-				};
-				const exports = await generatePackageExports(pkg.path, packageConfig, exportsConfig);
-				if (config.exports.autoUpdate) {
-					await updatePackageJsonExports(pkg.path, exports);
-					logger.info(`Updated exports for ${pkg.name}`);
-				}
-			}
-			logger.success(`Built ${pkg.name}`);
-		} catch (error) {
-			logger.error(`Failed to build ${pkg.name}:`, error);
-			throw error;
-		}
-	};
-	await buildWorkspacePackages(filteredPackages, buildPackage);
-	logger.success(`Successfully built ${filteredPackages.length} packages`);
-}
-function readJSON(specifier) {
-	return import(specifier, { with: { type: "json" } }).then((r) => r.default);
+async function readJSON(specifier) {
+	const module = await import(specifier, { with: { type: "json" } });
+	return module.default;
 }
 
 //#endregion
-export { build };
+export { build, performBuild };

package/dist/_chunks/{config-BDpkh_pL.d.mts → config-BOcpEsqS.d.mts}

@@ -445,35 +445,9 @@ interface BuildConfig {
   */
   fromVite?: boolean;
   /**
-  * Workspace configuration for monorepo support.
-  */
-  workspace?: WorkspaceConfig;
-  /**
   * Package exports generation configuration.
   */
   exports?: ExportsConfig;
-  /**
-  * Package filter for workspace builds.
-  */
-  filter?: string | string[];
-}
-interface WorkspaceConfig {
-  /**
-  * Workspace package patterns.
-  */
-  packages?: string[];
-  /**
-  * Package filter patterns.
-  */
-  filter?: string | string[];
-  /**
-  * Package exclude patterns.
-  */
-  exclude?: string | string[];
-  /**
-  * Build packages in dependency order.
-  */
-  dependencyOrder?: boolean;
 }
 interface ExportsConfig {
   /**

package/dist/_chunks/{package-UJXXVy4Q.mjs → package-Bz3LfrXJ.mjs}

@@ -1,7 +1,7 @@
 //#region package.json
 var name = "robuild";
 var type = "module";
-var version = "0.0.13";
+var version = "0.0.14";
 var packageManager = "pnpm@10.11.1";
 var description = "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc";
 var license = "MIT";
@@ -15,8 +15,8 @@ var types = "./dist/index.d.mts";
 var bin = "./dist/cli.mjs";
 var files = ["dist"];
 var scripts = {
-	"build": "pnpm robuild",
-	"dev": "pnpm vitest",
+	"build": "pnpm test:types && pnpm robuild",
+	"dev": "pnpm test",
 	"lint": "eslint .",
 	"lint:fix": "automd && eslint . --fix",
 	"robuild": "esno src/cli.ts",
@@ -24,7 +24,7 @@ var scripts = {
 	"release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
 	"test": "vitest run",
 	"test:watch": "vitest",
-	"test:types": "tsc --noEmit --skipLibCheck",
+	"test:types": "tsc --noEmit --skipLibCheck src/**/*.ts",
 	"docs:dev": "vitepress dev docs",
 	"docs:build": "vitepress build docs",
 	"docs:preview": "vitepress preview docs",

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { build } from "./_chunks/build-C9gSlxzR.mjs";
+import { build } from "./_chunks/build-Dtx2Wt3D.mjs";
 import { consola } from "consola";
 import { parseArgs } from "node:util";
 import { loadConfig } from "c12";
@@ -50,11 +50,6 @@ const args = parseArgs({
 			multiple: true
 		},
 		"from-vite": { type: "boolean" },
-		"workspace": { type: "boolean" },
-		"filter": {
-			type: "string",
-			multiple: true
-		},
 		"generate-exports": { type: "boolean" },
 		"cjs-default": { type: "string" },
 		"shims": { type: "boolean" },
@@ -85,8 +80,7 @@ Options:
   --fail-on-warn           Fail build on warnings
   --ignore-watch <pattern> Ignore patterns in watch mode (can be used multiple times)
   --from-vite              Load configuration from Vite config file
-  --workspace              Enable workspace mode for monorepo builds
-  --filter <pattern>       Filter workspace packages by name or path pattern (can be used multiple times)
+
   --generate-exports       Generate package.json exports field
   --cjs-default <mode>     CommonJS default export handling: true, false, auto (default: auto)
   --shims                  Enable CJS/ESM compatibility shims
@@ -168,11 +162,6 @@ if (args.values["on-success"]) buildConfig.onSuccess = args.values["on-success"]
 if (args.values["fail-on-warn"]) buildConfig.failOnWarn = true;
 if (args.values["ignore-watch"]) buildConfig.ignoreWatch = args.values["ignore-watch"];
 if (args.values["from-vite"]) buildConfig.fromVite = true;
-if (args.values.workspace) buildConfig.workspace = {
-	packages: ["packages/*", "apps/*"],
-	...config.workspace
-};
-if (args.values.filter) buildConfig.filter = args.values.filter;
 if (args.values["generate-exports"]) buildConfig.exports = {
 	enabled: true,
 	includeTypes: true,

package/dist/config.d.mts

@@ -1,2 +1,2 @@
-import { defineConfig } from "./_chunks/config-BDpkh_pL.mjs";
+import { defineConfig } from "./_chunks/config-BOcpEsqS.mjs";
 export { defineConfig };

package/dist/config.mjs

@@ -1,3 +1,3 @@
-import { defineConfig } from "./_chunks/config-B_2eqpNJ.mjs";
+import { defineConfig } from "./_chunks/config-C1aXyI1S.mjs";
 
 export { defineConfig };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { BuildConfig, BuildEntry, BundleEntry, TransformEntry, defineConfig } from "./_chunks/config-BDpkh_pL.mjs";
+import { BuildConfig, BuildEntry, BundleEntry, TransformEntry, defineConfig } from "./_chunks/config-BOcpEsqS.mjs";
 
 //#region src/build.d.ts
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { build } from "./_chunks/build-C9gSlxzR.mjs";
-import { defineConfig } from "./_chunks/config-B_2eqpNJ.mjs";
+import { build } from "./_chunks/build-Dtx2Wt3D.mjs";
+import { defineConfig } from "./_chunks/config-C1aXyI1S.mjs";
 
 export { build, defineConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robuild",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "packageManager": "pnpm@10.11.1",
   "description": "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc",
   "license": "MIT",
@@ -17,8 +17,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "pnpm robuild",
-    "dev": "pnpm vitest",
+    "build": "pnpm test:types && pnpm robuild",
+    "dev": "pnpm test",
     "lint": "eslint .",
     "lint:fix": "automd && eslint . --fix",
     "robuild": "esno src/cli.ts",
@@ -26,7 +26,7 @@
     "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:types": "tsc --noEmit --skipLibCheck",
+    "test:types": "tsc --noEmit --skipLibCheck src/**/*.ts",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs",