robuild 0.1.0 → 0.1.2

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

@@ -1,4 +1,4 @@
-import { t as RobuildPluginManager } from "./plugin-manager-CwMXjVtp.mjs";
+import { t as RobuildPluginManager } from "./manager-DyYf90Z5.mjs";
 import { builtinModules } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { colors } from "consola/utils";
@@ -9,19 +9,19 @@ import { parseSync } from "oxc-parser";
 import { rolldown, watch } from "rolldown";
 import { dts } from "rolldown-plugin-dts";
 import { existsSync, promises, readdirSync, statSync } from "node:fs";
-import { consola } from "consola";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { gzipSync } from "node:zlib";
 import { minify } from "oxc-minify";
-import { glob } from "glob";
+import { consola } from "consola";
 import { createHash } from "node:crypto";
+import { glob } from "glob";
 import MagicString from "magic-string";
 import { transform } from "oxc-transform";
 import { glob as glob$1 } from "tinyglobby";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 
-//#region src/features/logger.ts
+//#region src/core/logger.ts
 /**
 * Logger instance with configurable log level
 */
@@ -110,171 +110,199 @@ function shouldFailOnWarnings(failOnWarn) {
 }
 
 //#endregion
-//#region src/features/advanced-build.ts
+//#region src/utils/extensions.ts
 /**
-* Create skip node_modules plugin
+* Get file extension for a given format (with leading dot).
+* This is the unified function used by bundle, watch, and transform modes.
+*
+* @param format - The module format (es, cjs, iife, umd, etc.)
+* @param platform - The target platform
+* @param fixedExtension - Whether to force .cjs/.mjs extensions
+* @returns The file extension with leading dot (e.g., '.mjs', '.cjs', '.js')
 */
-function createSkipNodeModulesPlugin(options) {
-	const noExternalPatterns = options?.noExternal || [];
-	const shouldInline = (id) => {
-		for (const pattern of noExternalPatterns) if (typeof pattern === "string") {
-			if (id === pattern || id.startsWith(`${pattern}/`)) return true;
-		} else if (pattern instanceof RegExp) {
-			if (pattern.test(id)) return true;
-		}
-		return false;
-	};
-	return {
-		name: "skip-node-modules",
-		resolveId: async (id, importer) => {
-			if (shouldInline(id)) return null;
-			if (!importer) return null;
-			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\\")) return {
-				id,
-				external: true
-			};
-			return null;
-		}
-	};
+function getFormatExtension(format, platform = "node", fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" || format === "commonjs" ? ".cjs" : ".mjs";
+	switch (format) {
+		case "es":
+		case "esm":
+		case "module": return ".mjs";
+		case "cjs":
+		case "commonjs": return platform === "node" ? ".cjs" : ".js";
+		case "iife":
+		case "umd": return ".js";
+		default: return ".js";
+	}
 }
 /**
-* Unbundle mode: preserve file structure without bundling
+* Resolve JavaScript output extension (without leading dot).
+* @deprecated Use getFormatExtension() instead for consistency
 */
-async function unbundleTransform(ctx, entry) {
-	await processDirectoryUnbundled(isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input), join(ctx.pkgDir, entry.outDir || "dist"), entry);
+function resolveJsOutputExtension(format, platform = "node", fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" ? "cjs" : "mjs";
+	switch (format) {
+		case "es": return platform === "browser" ? "js" : "mjs";
+		case "cjs": return platform === "browser" ? "js" : "cjs";
+		case "iife":
+		case "umd": return "js";
+		default: return "js";
+	}
 }
 /**
-* Process directory in unbundle mode
+* Resolve DTS output extension
 */
-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);
+function resolveDtsOutputExtension(format, fixedExtension = false) {
+	if (fixedExtension) return format === "cjs" ? "d.cts" : "d.mts";
+	switch (format) {
+		case "es": return "d.mts";
+		case "cjs": return "d.cts";
+		default: return "d.ts";
 	}
 }
 /**
-* Process individual file in unbundle mode
+* Apply custom output extensions
 */
-async function processFileUnbundled(inputPath, outputPath, entry) {
-	const ext = extname(inputPath);
-	if (![
-		".js",
-		".ts",
-		".jsx",
-		".tsx",
-		".mjs",
-		".mts",
-		".cjs",
-		".cts"
-	].includes(ext)) return;
-	try {
-		const transformedContent = transformImportsForUnbundle(await readFile(inputPath, "utf-8"), inputPath, entry);
-		const outputExt = getUnbundleOutputExtension(ext, entry);
-		const finalOutputPath = outputPath.replace(ext, outputExt);
-		await mkdir(dirname(finalOutputPath), { recursive: true });
-		await writeFile(finalOutputPath, transformedContent, "utf-8");
-	} catch (error) {
-		logger.warn(`Failed to process file ${inputPath}:`, error);
+function applyOutExtensions(format, outExtensions) {
+	const defaultJs = resolveJsOutputExtension(format);
+	const defaultDts = resolveDtsOutputExtension(format);
+	if (!outExtensions) return {
+		js: defaultJs,
+		dts: defaultDts
+	};
+	const custom = outExtensions(format);
+	return {
+		js: custom.js || defaultJs,
+		dts: custom.dts || defaultDts
+	};
+}
+/**
+* Create filename with proper extension
+*/
+function createFilename(basename, format, isDts = false, options = {}) {
+	const { platform, fixedExtension, outExtensions } = options;
+	if (outExtensions) {
+		const extensions = applyOutExtensions(format, outExtensions);
+		return `${basename}.${isDts ? extensions.dts : extensions.js}`;
 	}
+	if (isDts) return `${basename}.${resolveDtsOutputExtension(format, fixedExtension)}`;
+	return `${basename}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
 }
+
+//#endregion
+//#region src/utils/hash.ts
 /**
-* Transform imports for unbundle mode
+* Generate content hash for filename
 */
-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;
+function generateContentHash(content, length = 8) {
+	return createHash("sha256").update(content).digest("hex").slice(0, length);
 }
 /**
-* Update import extension for unbundle mode
+* Add hash to filename
 */
-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;
+function addHashToFilename(filename, content, hashLength = 8) {
+	const hash = generateContentHash(content, hashLength);
+	const dotIndex = filename.lastIndexOf(".");
+	if (dotIndex === -1) return `${filename}-${hash}`;
+	return `${filename.slice(0, dotIndex)}-${hash}${filename.slice(dotIndex)}`;
 }
 /**
-* Get output extension for unbundle mode
+* Check if filename already has hash
 */
-function getUnbundleOutputExtension(inputExt, entry) {
-	const format = Array.isArray(entry.format) ? entry.format[0] : entry.format || "es";
-	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";
-	}
+function hasHash(filename) {
+	return /-[a-f0-9]{8}(?:\.|$)/.test(filename);
 }
 
 //#endregion
-//#region src/features/banner.ts
+//#region src/utils/node-protocol.ts
 /**
-* Resolve banner/footer addon for specific format
+* Node.js built-in modules that support the node: protocol
 */
-function resolveChunkAddon(addon, format) {
-	if (!addon) return;
-	if (typeof addon === "string") return addon;
-	return addon[format === "es" ? "js" : format] || addon.js;
+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 banner to content
+* Add node: prefix to built-in modules
 */
-function addBanner(content, banner) {
-	if (!banner) return content;
-	return `${banner}\n${content}`;
+function addNodeProtocol(id) {
+	if (id.startsWith("node:")) return id;
+	if (isNodeBuiltin(id)) return `node:${id}`;
+	return id;
 }
 /**
-* Add footer to content
+* Remove node: prefix from modules
 */
-function addFooter(content, footer) {
-	if (!footer) return content;
-	return `${content}\n${footer}`;
+function stripNodeProtocol(id) {
+	if (id.startsWith("node:")) return id.slice(5);
+	return id;
 }
 /**
-* Add both banner and footer to content
+* Process module ID based on nodeProtocol setting
 */
-function addBannerFooter(content, banner, footer) {
-	let result = content;
-	result = addBanner(result, banner);
-	result = addFooter(result, footer);
-	return result;
+function processNodeProtocol(id, nodeProtocol) {
+	if (nodeProtocol === "strip") return stripNodeProtocol(id);
+	if (nodeProtocol === true) return addNodeProtocol(id);
+	return id;
+}
+/**
+* Transform import/export statements to handle node protocol
+*/
+function transformNodeProtocol(code, nodeProtocol) {
+	if (!nodeProtocol) return code;
+	return code.replace(/(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g, (match, moduleId) => {
+		const processedId = processNodeProtocol(moduleId, nodeProtocol);
+		return match.replace(moduleId, processedId);
+	});
 }
 
 //#endregion
-//#region src/utils.ts
+//#region src/utils/index.ts
 /**
 * Normalize a path to an absolute path.
 * Handles string paths, URL objects, and undefined values.
@@ -362,219 +390,85 @@ async function sideEffectSize(dir, entry) {
 			}
 		}]
 	})).generate({ codeSplitting: false });
-	if (process.env.INSPECT_BUILD) {
-		logger.debug("---------[side effects]---------");
-		logger.debug(entry);
-		logger.debug(output[0].code);
-		logger.debug("-------------------------------");
-	}
-	return Buffer.byteLength(output[0].code.trim());
-}
-
-//#endregion
-//#region src/features/clean.ts
-/**
-* Clean output directory or specific paths.
-* Used by both bundle and transform builders.
-*
-* @param projectRoot - The project root directory
-* @param outDir - The output directory to clean
-* @param cleanPaths - true to clean outDir, or array of specific paths to clean
-*/
-async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
-	if (!cleanPaths) return;
-	if (cleanPaths === true) {
-		if (existsSync(outDir)) {
-			logger.log(colors.dim(`Cleaning ${fmtPath(outDir)}`));
-			await rm(outDir, {
-				recursive: true,
-				force: true
-			});
-		}
-	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
-		const fullPath = resolve(projectRoot, path);
-		if (existsSync(fullPath)) {
-			logger.log(colors.dim(`Cleaning ${fmtPath(fullPath)}`));
-			await rm(fullPath, {
-				recursive: true,
-				force: true
-			});
-		}
-	}
-}
-
-//#endregion
-//#region src/features/copy.ts
-/**
-* Copy files to output directory
-*/
-async function copyFiles(cwd, outDir, copyOptions) {
-	if (!copyOptions || copyOptions.length === 0) return;
-	logger.verbose("Copying files...");
-	await Promise.all(copyOptions.map(async (entry) => {
-		const from = typeof entry === "string" ? entry : entry.from;
-		const to = typeof entry === "string" ? resolve(outDir, basename(from)) : resolve(cwd, entry.to);
-		const fromPath = resolve(cwd, from);
-		try {
-			await cp(fromPath, to, {
-				recursive: true,
-				force: true
-			});
-			logger.verbose(`  ${from} → ${to}`);
-		} catch (error) {
-			logger.warn(`Failed to copy ${from} to ${to}:`, error);
-		}
-	}));
-	logger.verbose("Files copied successfully");
-}
-
-//#endregion
-//#region src/features/entry-resolver.ts
-/**
-* Parse a string entry format like "src/index.ts:dist" or "src/:dist"
-*
-* @param rawEntry - The raw string entry
-* @returns Parsed entry object
-*/
-function parseEntryString(rawEntry) {
-	const [input, outDir] = rawEntry.split(":");
-	if (input.endsWith("/")) return {
-		type: "transform",
-		input,
-		outDir: outDir || "dist"
-	};
-	return {
-		type: "bundle",
-		input: input.includes(",") ? input.split(",") : input,
-		outDir: outDir || "dist"
-	};
-}
-/**
-* Normalize entry input paths to absolute paths.
-* Handles string, array, and object (named entries) formats.
-*
-* @param entryInput - The entry input (string, array, or object)
-* @param pkgDir - The package directory to resolve paths from
-* @returns Normalized input
-*/
-function normalizeEntryInput(entryInput, pkgDir) {
-	if (typeof entryInput === "object" && !Array.isArray(entryInput)) {
-		const normalizedInput = {};
-		for (const [key, value] of Object.entries(entryInput)) normalizedInput[key] = normalizePath(value, pkgDir);
-		return normalizedInput;
-	}
-	if (Array.isArray(entryInput)) return entryInput.map((p) => normalizePath(p, pkgDir));
-	return normalizePath(entryInput, pkgDir);
-}
-/**
-* Get the entry input from a BundleEntry, supporting both 'input' and 'entry' fields.
-* This provides tsup compatibility.
-*
-* @param entry - The bundle entry
-* @returns The entry input or undefined
-*/
-function getBundleEntryInput(entry) {
-	return entry.input || entry.entry;
-}
-/**
-* Check if an entry has valid input.
-*
-* @param entry - The entry to check
-* @returns true if the entry has valid input
-*/
-function hasValidInput(entry) {
-	if (entry.type === "transform") return !!entry.input;
-	return !!getBundleEntryInput(entry);
-}
-
-//#endregion
-//#region src/features/extensions.ts
-/**
-* Get file extension for a given format (with leading dot).
-* This is the unified function used by bundle, watch, and transform modes.
-*
-* @param format - The module format (es, cjs, iife, umd, etc.)
-* @param platform - The target platform
-* @param fixedExtension - Whether to force .cjs/.mjs extensions
-* @returns The file extension with leading dot (e.g., '.mjs', '.cjs', '.js')
-*/
-function getFormatExtension(format, platform = "node", fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" || format === "commonjs" ? ".cjs" : ".mjs";
-	switch (format) {
-		case "es":
-		case "esm":
-		case "module": return ".mjs";
-		case "cjs":
-		case "commonjs": return platform === "node" ? ".cjs" : ".js";
-		case "iife":
-		case "umd": return ".js";
-		default: return ".js";
-	}
-}
-/**
-* Resolve JavaScript output extension (without leading dot).
-* @deprecated Use getFormatExtension() instead for consistency
-*/
-function resolveJsOutputExtension(format, platform = "node", fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" ? "cjs" : "mjs";
-	switch (format) {
-		case "es": return platform === "browser" ? "js" : "mjs";
-		case "cjs": return platform === "browser" ? "js" : "cjs";
-		case "iife":
-		case "umd": return "js";
-		default: return "js";
-	}
-}
-/**
-* Resolve DTS output extension
-*/
-function resolveDtsOutputExtension(format, fixedExtension = false) {
-	if (fixedExtension) return format === "cjs" ? "d.cts" : "d.mts";
-	switch (format) {
-		case "es": return "d.mts";
-		case "cjs": return "d.cts";
-		default: return "d.ts";
+	if (process.env.INSPECT_BUILD) {
+		logger.debug("---------[side effects]---------");
+		logger.debug(entry);
+		logger.debug(output[0].code);
+		logger.debug("-------------------------------");
 	}
+	return Buffer.byteLength(output[0].code.trim());
 }
+
+//#endregion
+//#region src/config/entry-resolver.ts
 /**
-* Apply custom output extensions
+* Parse a string entry format like "src/index.ts:dist" or "src/:dist"
+*
+* @param rawEntry - The raw string entry
+* @returns Parsed entry object
 */
-function applyOutExtensions(format, outExtensions) {
-	const defaultJs = resolveJsOutputExtension(format);
-	const defaultDts = resolveDtsOutputExtension(format);
-	if (!outExtensions) return {
-		js: defaultJs,
-		dts: defaultDts
+function parseEntryString(rawEntry) {
+	const [input, outDir] = rawEntry.split(":");
+	if (input.endsWith("/")) return {
+		type: "transform",
+		input,
+		outDir: outDir || "dist"
 	};
-	const custom = outExtensions(format);
 	return {
-		js: custom.js || defaultJs,
-		dts: custom.dts || defaultDts
+		type: "bundle",
+		input: input.includes(",") ? input.split(",") : input,
+		outDir: outDir || "dist"
 	};
 }
 /**
-* Create filename with proper extension
+* Normalize entry input paths to absolute paths.
+* Handles string, array, and object (named entries) formats.
+*
+* @param entryInput - The entry input (string, array, or object)
+* @param pkgDir - The package directory to resolve paths from
+* @returns Normalized input
 */
-function createFilename(basename, format, isDts = false, options = {}) {
-	const { platform, fixedExtension, outExtensions } = options;
-	if (outExtensions) {
-		const extensions = applyOutExtensions(format, outExtensions);
-		return `${basename}.${isDts ? extensions.dts : extensions.js}`;
+function normalizeEntryInput(entryInput, pkgDir) {
+	if (typeof entryInput === "object" && !Array.isArray(entryInput)) {
+		const normalizedInput = {};
+		for (const [key, value] of Object.entries(entryInput)) normalizedInput[key] = normalizePath(value, pkgDir);
+		return normalizedInput;
 	}
-	if (isDts) return `${basename}.${resolveDtsOutputExtension(format, fixedExtension)}`;
-	return `${basename}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
+	if (Array.isArray(entryInput)) return entryInput.map((p) => normalizePath(p, pkgDir));
+	return normalizePath(entryInput, pkgDir);
+}
+/**
+* Get the entry input from a BundleEntry, supporting both 'input' and 'entry' fields.
+* This provides tsup compatibility.
+*
+* @param entry - The bundle entry
+* @returns The entry input or undefined
+*/
+function getBundleEntryInput(entry) {
+	return entry.input || entry.entry;
+}
+/**
+* Check if an entry has valid input.
+*
+* @param entry - The entry to check
+* @returns true if the entry has valid input
+*/
+function hasValidInput(entry) {
+	if (entry.type === "transform") return !!entry.input;
+	return !!getBundleEntryInput(entry);
 }
 
 //#endregion
-//#region src/features/external.ts
+//#region src/config/external.ts
 /**
 * Build external dependencies list from package.json dependencies and peerDependencies.
 * This is the shared logic used by both bundle and watch modes.
 */
 function buildExternalDeps(ctx) {
+	const excludedBuiltins = new Set(["module"]);
 	return [
-		...builtinModules,
-		...builtinModules.map((m) => `node:${m}`),
+		...builtinModules.filter((m) => !excludedBuiltins.has(m)),
+		...builtinModules.filter((m) => !excludedBuiltins.has(m)).map((m) => `node:${m}`),
 		...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, new RegExp(`^${p}/`)])
 	];
 }
@@ -648,7 +542,36 @@ function resolveExternalConfig(ctx, options) {
 }
 
 //#endregion
-//#region src/features/glob-import.ts
+//#region src/plugins/builtin/glob-import.ts
+/**
+* Core transform logic for glob imports
+*/
+async function transformGlobImportCode(code, id, options) {
+	const { patterns, asUrls, eager } = options;
+	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, , pattern, optionsStr] = match;
+		let globOptions = {};
+		if (optionsStr) try {
+			globOptions = parseGlobOptions(optionsStr);
+		} catch {
+			logger.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) {
+			logger.error(`Failed to process glob import ${pattern}:`, error);
+		}
+	}
+	return hasGlobImports ? transformedCode : null;
+}
 /**
 * Create a glob import plugin for robuild
 */
@@ -657,30 +580,12 @@ function createGlobImportPlugin(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, , pattern, optionsStr] = match;
-				let globOptions = {};
-				if (optionsStr) try {
-					globOptions = parseGlobOptions(optionsStr);
-				} catch {
-					logger.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) {
-					logger.error(`Failed to process glob import ${pattern}:`, error);
-				}
-			}
-			return hasGlobImports ? transformedCode : null;
+		transform: async (code, id, _meta) => {
+			return transformGlobImportCode(code, id, {
+				patterns,
+				asUrls,
+				eager
+			});
 		}
 	};
 }
@@ -753,33 +658,54 @@ function parseGlobOptions(optionsStr) {
 	if (asMatch) options.as = asMatch[1];
 	return options;
 }
-
-//#endregion
-//#region src/features/hash.ts
 /**
-* Generate content hash for filename
+* Check if code contains glob imports
 */
-function generateContentHash(content, length = 8) {
-	return createHash("sha256").update(content).digest("hex").slice(0, length);
+function hasGlobImports(code) {
+	return /import\.meta\.glob\s*\(/.test(code);
 }
+
+//#endregion
+//#region src/plugins/builtin/node-protocol.ts
 /**
-* Add hash to filename
+* Rolldown plugin for Node.js protocol handling
 */
-function addHashToFilename(filename, content, hashLength = 8) {
-	const hash = generateContentHash(content, hashLength);
-	const dotIndex = filename.lastIndexOf(".");
-	if (dotIndex === -1) return `${filename}-${hash}`;
-	return `${filename.slice(0, dotIndex)}-${hash}${filename.slice(dotIndex)}`;
+function nodeProtocolPlugin(nodeProtocol) {
+	if (!nodeProtocol) return { name: "node-protocol-noop" };
+	return {
+		name: "node-protocol",
+		renderChunk(code) {
+			return {
+				code: transformNodeProtocol(code, nodeProtocol),
+				map: null
+			};
+		}
+	};
 }
-/**
-* Check if filename already has hash
-*/
-function hasHash(filename) {
-	return /-[a-f0-9]{8}(?:\.|$)/.test(filename);
+
+//#endregion
+//#region src/plugins/builtin/shebang.ts
+const SHEBANG_RE = /^#![^\n]*/;
+function shebangPlugin() {
+	return {
+		name: "robuild-shebang",
+		async writeBundle(options, bundle) {
+			for (const [fileName, output] of Object.entries(bundle)) {
+				if (output.type !== "chunk") continue;
+				if (hasShebang(output.code)) await makeExecutable(resolve(options.dir, fileName));
+			}
+		}
+	};
+}
+function hasShebang(code) {
+	return SHEBANG_RE.test(code);
+}
+async function makeExecutable(filePath) {
+	await promises.chmod(filePath, 493).catch(() => {});
 }
 
 //#endregion
-//#region src/features/shims.ts
+//#region src/plugins/builtin/shims.ts
 /**
 * Default shims configuration
 */
@@ -893,134 +819,155 @@ function createShimsPlugin(config = true) {
 		}
 	};
 }
-
-//#endregion
-//#region src/features/node-protocol.ts
 /**
-* Node.js built-in modules that support the node: protocol
+* Create browser-specific shims plugin
 */
-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"
-]);
+function createBrowserShimsPlugin() {
+	return {
+		name: "browser-shims",
+		transform: async (code, id) => {
+			if (!/\.(?:js|mjs|jsx|tsx?)$/.test(id)) return null;
+			if (detectShimNeeds(code).needsEnv) return `${PROCESS_ENV_SHIM}\n${code}`;
+			return null;
+		}
+	};
+}
 /**
-* Check if a module is a Node.js built-in module
+* Create Node.js-specific shims plugin
 */
-function isNodeBuiltin(id) {
-	const cleanId = id.startsWith("node:") ? id.slice(5) : id;
-	return NODE_BUILTIN_MODULES.has(cleanId);
+function createNodeShimsPlugin() {
+	return {
+		name: "node-shims",
+		transform: async (code, id) => {
+			if (!/\.mjs$/.test(id) && !/\.js$/.test(id)) return null;
+			const needs = detectShimNeeds(code);
+			const shims = [];
+			if (needs.needsDirname || needs.needsRequire) shims.push(NODE_GLOBALS_SHIM);
+			if (needs.needsExports) shims.push(MODULE_EXPORTS_SHIM);
+			if (shims.length === 0) return null;
+			return `${shims.join("\n")}\n${code}`;
+		}
+	};
 }
+
+//#endregion
+//#region src/plugins/builtin/skip-node-modules.ts
 /**
-* Add node: prefix to built-in modules
+* Create skip node_modules plugin
 */
-function addNodeProtocol(id) {
-	if (id.startsWith("node:")) return id;
-	if (isNodeBuiltin(id)) return `node:${id}`;
-	return id;
+function createSkipNodeModulesPlugin(options) {
+	const noExternalPatterns = options?.noExternal || [];
+	const shouldInline = (id) => {
+		for (const pattern of noExternalPatterns) if (typeof pattern === "string") {
+			if (id === pattern || id.startsWith(`${pattern}/`)) return true;
+		} else if (pattern instanceof RegExp) {
+			if (pattern.test(id)) return true;
+		}
+		return false;
+	};
+	return {
+		name: "skip-node-modules",
+		resolveId: async (id, importer) => {
+			if (shouldInline(id)) return null;
+			if (!importer) return null;
+			if (id.includes("node_modules") || !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\\")) return {
+				id,
+				external: true
+			};
+			return null;
+		}
+	};
 }
+
+//#endregion
+//#region src/transforms/banner.ts
 /**
-* Remove node: prefix from modules
+* Resolve banner/footer addon for specific format
 */
-function stripNodeProtocol(id) {
-	if (id.startsWith("node:")) return id.slice(5);
-	return id;
+function resolveChunkAddon(addon, format) {
+	if (!addon) return;
+	if (typeof addon === "string") return addon;
+	return addon[format === "es" ? "js" : format] || addon.js;
 }
 /**
-* Process module ID based on nodeProtocol setting
+* Add banner to content
 */
-function processNodeProtocol(id, nodeProtocol) {
-	if (nodeProtocol === "strip") return stripNodeProtocol(id);
-	if (nodeProtocol === true) return addNodeProtocol(id);
-	return id;
+function addBanner(content, banner) {
+	if (!banner) return content;
+	return `${banner}\n${content}`;
 }
 /**
-* Transform import/export statements to handle node protocol
+* Add footer to content
 */
-function transformNodeProtocol(code, nodeProtocol) {
-	if (!nodeProtocol) return code;
-	return code.replace(/(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g, (match, moduleId) => {
-		const processedId = processNodeProtocol(moduleId, nodeProtocol);
-		return match.replace(moduleId, processedId);
-	});
+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/plugins/node-protocol.ts
+//#region src/transforms/clean.ts
 /**
-* Rolldown plugin for Node.js protocol handling
+* Clean output directory or specific paths.
+* Used by both bundle and transform builders.
+*
+* @param projectRoot - The project root directory
+* @param outDir - The output directory to clean
+* @param cleanPaths - true to clean outDir, or array of specific paths to clean
 */
-function nodeProtocolPlugin(nodeProtocol) {
-	if (!nodeProtocol) return { name: "node-protocol-noop" };
-	return {
-		name: "node-protocol",
-		renderChunk(code) {
-			return {
-				code: transformNodeProtocol(code, nodeProtocol),
-				map: null
-			};
+async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
+	if (!cleanPaths) return;
+	if (cleanPaths === true) {
+		if (existsSync(outDir)) {
+			logger.log(colors.dim(`Cleaning ${fmtPath(outDir)}`));
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
 		}
-	};
+	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
+		const fullPath = resolve(projectRoot, path);
+		if (existsSync(fullPath)) {
+			logger.log(colors.dim(`Cleaning ${fmtPath(fullPath)}`));
+			await rm(fullPath, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
 }
 
 //#endregion
-//#region src/plugins/shebang.ts
-const SHEBANG_RE = /^#![^\n]*/;
-function shebangPlugin() {
-	return {
-		name: "robuild-shebang",
-		async writeBundle(options, bundle) {
-			for (const [fileName, output] of Object.entries(bundle)) {
-				if (output.type !== "chunk") continue;
-				if (hasShebang(output.code)) await makeExecutable(resolve(options.dir, fileName));
-			}
+//#region src/transforms/copy.ts
+/**
+* Copy files to output directory
+*/
+async function copyFiles(cwd, outDir, copyOptions) {
+	if (!copyOptions || copyOptions.length === 0) return;
+	logger.verbose("Copying files...");
+	await Promise.all(copyOptions.map(async (entry) => {
+		const from = typeof entry === "string" ? entry : entry.from;
+		const to = typeof entry === "string" ? resolve(outDir, basename(from)) : resolve(cwd, entry.to);
+		const fromPath = resolve(cwd, from);
+		try {
+			await cp(fromPath, to, {
+				recursive: true,
+				force: true
+			});
+			logger.verbose(`  ${from} → ${to}`);
+		} catch (error) {
+			logger.warn(`Failed to copy ${from} to ${to}:`, error);
 		}
-	};
-}
-function hasShebang(code) {
-	return SHEBANG_RE.test(code);
-}
-async function makeExecutable(filePath) {
-	await promises.chmod(filePath, 493).catch(() => {});
+	}));
+	logger.verbose("Files copied successfully");
 }
 
 //#endregion
@@ -1253,6 +1200,110 @@ function normalizeBundleInputs(input, ctx) {
 	return inputs;
 }
 
+//#endregion
+//#region src/builders/unbundle.ts
+/**
+* Unbundle mode: preserve file structure without bundling
+*/
+async function unbundleTransform(ctx, entry) {
+	await processDirectoryUnbundled(isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input), join(ctx.pkgDir, entry.outDir || "dist"), entry);
+}
+/**
+* Process directory in unbundle mode
+*/
+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 transformedContent = transformImportsForUnbundle(await readFile(inputPath, "utf-8"), inputPath, entry);
+		const outputExt = getUnbundleOutputExtension(ext, entry);
+		const finalOutputPath = outputPath.replace(ext, outputExt);
+		await mkdir(dirname(finalOutputPath), { recursive: true });
+		await writeFile(finalOutputPath, transformedContent, "utf-8");
+	} catch (error) {
+		logger.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 || "es";
+	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/builders/transform.ts
 /**
@@ -1415,44 +1466,7 @@ async function transformModule(entryPath, entry) {
 }
 
 //#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
+//#region src/config/vite-config.ts
 /**
 * Load Vite configuration and convert to robuild config
 */
@@ -1562,13 +1576,50 @@ function convertExternal(external) {
 	return external;
 }
 
+//#endregion
+//#region src/transforms/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/watch.ts
 /**
 * Perform watch build using rolldown's built-in watch mode
 */
 async function performWatchBuild(config, ctx, startTime) {
-	const { performBuild } = await import("./build-tpynh1ZI.mjs");
+	const { performBuild } = await import("./build-DsVOIGdc.mjs");
 	await performBuild(config, ctx, startTime);
 	const bundleEntries = (config.entries || []).filter((entry) => {
 		if (typeof entry === "string") return !entry.endsWith("/");
@@ -1589,7 +1640,7 @@ async function performWatchBuild(config, ctx, startTime) {
 */
 async function startRolldownWatch(config, ctx, bundleEntries) {
 	logger.info("Watching for changes...");
-	const { RobuildPluginManager } = await import("./plugin-manager-pCQvlo7q.mjs");
+	const { RobuildPluginManager } = await import("./manager-CnmjrU85.mjs");
 	const watchConfigs = [];
 	for (const rawEntry of bundleEntries) {
 		const entry = typeof rawEntry === "string" ? parseEntryString(rawEntry) : rawEntry;
@@ -1684,7 +1735,8 @@ const SHARED_CONFIG_FIELDS = [
 	"footer",
 	"shims",
 	"rolldown",
-	"loaders"
+	"loaders",
+	"clean"
 ];
 /**
 * Inherit configuration from parent config to entry
@@ -1786,4 +1838,4 @@ async function readJSON(specifier) {
 }
 
 //#endregion
-export { makeExecutable as a, configureLogger as c, hasShebang as i, logger as l, performBuild as n, shebangPlugin as o, SHEBANG_RE as r, nodeProtocolPlugin as s, build as t };
+export { createBrowserShimsPlugin as a, SHEBANG_RE as c, shebangPlugin as d, nodeProtocolPlugin as f, logger as g, configureLogger as h, DEFAULT_SHIMS_CONFIG as i, hasShebang as l, hasGlobImports as m, performBuild as n, createNodeShimsPlugin as o, createGlobImportPlugin as p, createSkipNodeModulesPlugin as r, createShimsPlugin as s, build as t, makeExecutable as u };