robuild 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Sunny-117
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,265 @@
+# tsbuild
+
+⚡️ Bundle your TypeScript library with no config, powered by esbuild、swc、rollup ...
+
+## 特点
+
+1. 基于 esbuild 开发：无需关心内部构建逻辑，一键式构建
+2. 覆盖常用的构建能力：通过 Plugin 式开发，完美支持 esbuild 的构建功能
+3. 支持 ES5：借助 SWC 能力，支持构建至 ES5 环境
+
+## 技术选型
+
+- 包管理工具：pnpm；
+- 命令行交互：cac；
+- 基础构建工具：esbuild、rollup、swc；
+- 文件读取工具：JoyCon；
+- 代码runtime 转换工具：sucrase；
+- 代码语法检查工具：typescript；
+- 代码压缩：terser；
+- 代码文件监听：chokidar；
+- 静态站点：docusaurus；
+- 测试工具：vitest；
+
+## 安装
+
+```bash
+# 建议当前项目中安装
+pnpm i tsbuild  -D
+
+# 也可以全局安装，但不推荐
+pnpm i tsbuild -g
+```
+
+## 基础使用
+
+```bash
+tsbuild [...files]
+```
+
+文件默认会构建至 `dist`目录下。
+
+## 支持多入口
+
+```bash
+tsbuild src/index.ts src/cli.ts
+```
+
+会在`dist`目录下产出`index.js`与`cli.js`。
+
+也可以使用`CLI`的指令执行相同的功能
+
+```bash
+# 构建结果为 dist/index.js dist/cli.js
+tsbuild --entry src/index.ts --entry src/cli.ts
+```
+
+也可以指定构建后的文件名称
+
+```bash
+# 构建结果为 dist/foo.js 和 dist/bar.js
+tsbuild --entry.foo src/index.ts --entry.bar src/cli.ts
+```
+
+也可以在 `encode-config.ts` 中配置：
+
+```typescript
+export default defineConfig({
+  // 输出 dist/a.js 和 dist/b.js
+  entry: ['src/a.ts', 'src/b.ts'],
+  // 输出 dist/foo.js 和 dist/bar.js
+  entry: {
+    foo: 'src/a.ts',
+    bar: 'src/b.ts',
+  },
+})
+```
+
+## 设置 exclude
+
+默认情况下，除了生产环境下所依赖的模块(`peerDependencies`和`dependencies`)外，会自动构建其他的模块，如果不希望构建，可以使用`--external`避免构建。
+
+## 自定义配置
+
+可以使用如下配置
+
+- `tsbuild.config.ts`
+- `tsbuild.config.js`
+- `tsbuild.config.cjs`
+- `tsbuild.config.json`
+- 在`package.json`中的`tsbuild`
+
+也可以使用`defineConfig`来进行定制化配置。
+
+```typescript
+import { defineConfig } from 'tsbuild'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+})
+```
+
+也可以在`package.json`中进行配置。
+
+```json
+{
+  "tsbuild": {
+    "entry": ["src/index.ts"],
+    "splitting": false,
+    "sourcemap": true,
+    "clean": true
+  }
+}
+```
+
+## 生成声明文件
+
+```bash
+tsbuild index.ts --dts
+```
+
+以上指令会导出`./dist/index.js`和`./dist/index.d.ts`，当导出多种构建格式时，每种构建格式都会生成一个声明文件。
+
+如果有多个入口文件，每个入口文件都会生成一个对应的`.d.ts`文件。因此，如果想对单个入口文件生成声明文件时，请使用 ` --dts <entry>`` 格式，例如 `--dts src/index.ts`。
+
+请注意，`--dts`不会解析 `.d.ts` 文件中使用的外部（比如`node_modules`）类型，如果这是某种要求，可以使用 `--dts-resolve`。
+
+## 只导出声明文件
+
+`--dts-only` 指令等同于`tsc`的`emitDeclarationOnly`。可以使用此指令只生成声明文件。
+
+## 生成 sourcemap
+
+```bash
+tsbuild index.ts --sourcemap
+```
+
+会导出 `./dist/index.js` and `./dist/index.js.map`。
+
+如果有多个入口文件，每个入口文件都会生成相对于的`.map`文件。
+
+## 构建产物格式
+
+支持`ESM`、`CJS`和`IIFE`。
+
+可以一次性构建多种类型：
+
+```bash
+tsbuild src/index.ts --format esm,cjs,iife
+```
+
+将会生成以下文件结构：
+
+```bash
+dist
+├── index.mjs         # esm
+├── index.global.js   # iife
+└── index.js          # cjs
+```
+
+如果`package.json`中的`type`配置为`module`，产出结果会有所不同：
+
+```bash
+dist
+├── index.js          # esm
+├── index.global.js   # iife
+└── index.cjs         # cjs
+```
+
+如果不想使用诸如`.mjs`或者`.cjs`这类文件后缀，或者当前环境不支持此后缀，可以使用`--legacy-output`
+
+```bash
+tsbuild src/index.ts --format esm,cjs,iife --legacy-output
+```
+
+会构建成:
+
+```bash
+dist
+├── esm
+│   └── index.js
+├── iife
+│   └── index.js
+└── index.js
+```
+
+## 代码分割
+
+目前代码分隔只支持`ESM`的产物类型，并且默认是开启的，如果想针对`CJS`的文件类型设置代码分隔，请设置`--splitting`，会启用`esbuild`的代码分隔功能。
+
+对应地，如果想关闭代码分隔，请使用`--no-splitting`。
+
+## 目标环境
+
+此处默认使用`tsconfig`中的`compilerOptions.target`，也可以使用`--target`来手动声明。
+
+## 支持 ES5
+
+可以使用`--target es5`指令来将代码编译构建至 ES5 版本，代码首先会构建成`ES2020`，然后借助 SWC 编译成`ES5`。
+
+## watch 模式
+
+```bash
+tsbuild src/index.ts --watch
+```
+
+启动`watch`模式，这意味着在初始构建后，tsbuild 会监听文件变化。
+
+可以使用`--ignore-watch`来取消指定文件的监听。
+
+```bash
+tsbuild src src/index.ts --watch --ignore-watch folder1 --ignore-watch folder2
+```
+
+## 成功回调
+
+```bash
+tsbuild src/index.ts --watch --onSuccess "node dist/index.js"
+```
+
+`--onSuccess`会返回`Promise`类型的函数，可以执行类似如下功能
+
+```typescript
+import { defineConfig } from 'tsbuild'
+
+export default defineConfig({
+  async onSuccess() {
+    const server = http.createServer((req, res) => {
+      res.end('Encode Studio!')
+    })
+    server.listen(3000)
+    return () => {
+      server.close()
+    }
+  },
+})
+```
+
+## 压缩代码
+
+可以使用`--minify`来压缩代码
+
+```bash
+tsbuild src/index.ts --minify
+```
+
+或者使用`terser`而不是 esbuild 来压缩代码，前提条件是要先安装`terser`
+
+```bash
+tsbuild src/index.ts --minify
+```
+
+## tree shaking
+
+`esbuild`默认开启`tree shaking`，但是特殊情况下（如：[external 模块](https://github.com/evanw/esbuild/issues/1794)或者[未使用的引用](https://github.com/evanw/esbuild/issues/1435)）等情况还是有些问题。
+
+提供`--treeshake`指令来启用`rollup`的`tree shaking`。
+
+针对更多帮助，请使用`tsbuild --help`。
+
+## how-a-package-is-resolved
+
+<img src="./assets/how-a-package-is-resolved.jpeg">

package/dist/_chunks/build-Dn4aJvxA.mjs

@@ -0,0 +1,388 @@
+import { mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+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 { builtinModules } from "node:module";
+import { defu } from "defu";
+import { resolveModulePath } from "exsolve";
+import oxcParser from "oxc-parser";
+import { rolldown } from "rolldown";
+import { dts } from "rolldown-plugin-dts";
+import { promises, readdirSync, statSync } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { minify } from "oxc-minify";
+import MagicString from "magic-string";
+import oxcTransform from "oxc-transform";
+import { glob } from "tinyglobby";
+
+//#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/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
+async function rolldownBuild(ctx, entry, hooks) {
+	const inputs = normalizeBundleInputs(entry.input, ctx);
+	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 = oxcParser.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 rolldownConfig = defu(entry.rolldown, {
+		cwd: ctx.pkgDir,
+		input: inputs,
+		plugins: [shebangPlugin()],
+		platform: "neutral",
+		external: [
+			...builtinModules,
+			...builtinModules.map((m) => `node:${m}`),
+			...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, new RegExp(`^${p}/`)])
+		]
+	});
+	if (entry.dts !== false) rolldownConfig.plugins.push(...dts({ ...entry.dts }));
+	await hooks.rolldownConfig?.(rolldownConfig, ctx);
+	const res = await rolldown(rolldownConfig);
+	const outDir = resolve(ctx.pkgDir, entry.outDir || "dist");
+	const outConfig = {
+		dir: outDir,
+		entryFileNames: "[name].mjs",
+		chunkFileNames: "_chunks/[name]-[hash].mjs",
+		minify: entry.minify
+	};
+	await hooks.rolldownOutput?.(outConfig, res, ctx);
+	const { output } = await res.write(outConfig);
+	await res.close();
+	const outputEntries = [];
+	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 [...deps].sort();
+	};
+	for (const chunk of output) {
+		if (chunk.type !== "chunk" || !chunk.isEntry) continue;
+		if (chunk.fileName.endsWith("ts")) continue;
+		outputEntries.push({
+			name: chunk.fileName,
+			exports: chunk.exports,
+			deps: resolveDeps(chunk),
+			...await distSize(outDir, chunk.fileName),
+			sideEffectSize: await sideEffectSize(outDir, chunk.fileName)
+		});
+	}
+	consola.log(`\n${outputEntries.map((o) => [
+		`${colors.magenta(`[bundle] `)}${colors.underline(fmtPath(join(outDir, 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/builders/transform.ts
+/**
+* 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;
+	}
+	const promises$1 = [];
+	for await (const entryName of await glob("**/*.*", { 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 entryDistPath = join(entry.outDir, entryName.replace(/\.ts$/, ".mjs"));
+				await mkdir(dirname(entryDistPath), { recursive: true });
+				await writeFile(entryDistPath, transformed.code, "utf8");
+				if (SHEBANG_RE.test(transformed.code)) await makeExecutable(entryDistPath);
+				if (transformed.declaration) await writeFile(entryDistPath.replace(/\.mjs$/, ".d.mts"), 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);
+	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 = oxcParser.parseSync(entryPath, sourceText, { ...sourceOptions });
+	if (parsed.errors.length > 0) throw new Error(`Errors while parsing ${entryPath}:`, { cause: parsed.errors });
+	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) => {
+		const moduleId = req.value;
+		if (!moduleId.startsWith(".")) 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 = oxcTransform.transform(entryPath, sourceText, {
+		...entry.oxc,
+		...sourceOptions,
+		cwd: dirname(entryPath),
+		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");
+		throw new Error(`Errors while transforming ${entryPath}: (hint: check build-dump.ts)`, { cause: transformErrors });
+	}
+	if (entry.minify) {
+		const res = minify(entryPath, transformed.code, entry.minify === true ? {} : entry.minify);
+		transformed.code = res.code;
+		transformed.map = res.map;
+	}
+	return transformed;
+}
+
+//#endregion
+//#region src/build.ts
+/**
+* Build dist/ from src/
+*/
+async function build(config) {
+	const start = Date.now();
+	const pkgDir = normalizePath(config.cwd);
+	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
+	const ctx = {
+		pkg,
+		pkgDir
+	};
+	consola.log(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+	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", pkgDir);
+		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, pkgDir)) : normalizePath(entry.input, 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 outDir of outDirs) {
+		consola.log(`🧻 Cleaning up \`${fmtPath(outDir)}\``);
+		await rm(outDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	for (const entry of entries) await (entry.type === "bundle" ? rolldownBuild(ctx, entry, hooks) : transformDir(ctx, entry));
+	await hooks.end?.(ctx);
+	const dirSize = analyzeDir(outDirs);
+	consola.log(colors.dim(`\nΣ Total dist byte size: ${colors.underline(prettyBytes(dirSize.size))} (${colors.underline(dirSize.files)} files)`));
+	consola.log(`\n✅ robuild finished in ${Date.now() - start}ms`);
+}
+function normalizePath(path, resolveFrom) {
+	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
+}
+function readJSON(specifier) {
+	return import(specifier, { with: { type: "json" } }).then((r) => r.default);
+}
+
+//#endregion
+export { build };

package/dist/_chunks/types-1AA9vjTS.d.mts

@@ -0,0 +1,96 @@
+import { ResolveOptions } from "exsolve";
+import { InputOptions, MinifyOptions, OutputOptions, RolldownBuild, RolldownPluginOption } from "rolldown";
+import { Options } from "rolldown-plugin-dts";
+import { MinifyOptions as MinifyOptions$1 } from "oxc-minify";
+import { TransformOptions } from "oxc-transform";
+
+//#region src/types.d.ts
+interface BuildContext {
+  pkgDir: string;
+  pkg: {
+    name: string;
+  } & Record<string, unknown>;
+}
+interface _BuildEntry {
+  /**
+  * Output directory relative to project root.
+  *
+  * Defaults to `dist/` if not provided.
+  */
+  outDir?: string;
+  /**
+  * Avoid actual build but instead link to the source files.
+  */
+  stub?: boolean;
+}
+type BundleEntry = _BuildEntry & {
+  type: "bundle";
+  /**
+  * Entry point(s) to bundle relative to the project root.
+  */
+  input: string | string[];
+  /**
+  * Minify the output using rolldown.
+  *
+  * Defaults to `false` if not provided.
+  */
+  minify?: boolean | "dce-only" | MinifyOptions;
+  /**
+  * Options passed to rolldown.
+  *
+  * See [rolldown config options](https://rolldown.rs/reference/config-options) for more details.
+  */
+  rolldown?: InputOptions & {
+    plugins?: RolldownPluginOption[];
+  };
+  /**
+  * Declaration generation options.
+  *
+  * See [rolldown-plugin-dts](https://github.com/sxzz/rolldown-plugin-dts) for more details.
+  *
+  * Options are inferred from the `tsconfig.json` file if available.
+  *
+  * Set to `false` to disable.
+  */
+  dts?: boolean | Options;
+};
+type TransformEntry = _BuildEntry & {
+  type: "transform";
+  /**
+  * Directory to transform relative to the project root.
+  */
+  input: string;
+  /**
+  * Minify the output using oxc-minify.
+  *
+  * Defaults to `false` if not provided.
+  */
+  minify?: boolean | MinifyOptions$1;
+  /**
+  * Options passed to oxc-transform.
+  *
+  * See [oxc-transform](https://www.npmjs.com/package/oxc-transform) for more details.
+  */
+  oxc?: TransformOptions;
+  /**
+  * Options passed to exsolve for module resolution.
+  *
+  * See [exsolve](https://github.com/unjs/exsolve) for more details.
+  */
+  resolve?: Omit<ResolveOptions, "from">;
+};
+type BuildEntry = BundleEntry | TransformEntry;
+interface BuildHooks {
+  start?: (ctx: BuildContext) => void | Promise<void>;
+  end?: (ctx: BuildContext) => void | Promise<void>;
+  entries?: (entries: BuildEntry[], ctx: BuildContext) => void | Promise<void>;
+  rolldownConfig?: (cfg: InputOptions, ctx: BuildContext) => void | Promise<void>;
+  rolldownOutput?: (cfg: OutputOptions, res: RolldownBuild, ctx: BuildContext) => void | Promise<void>;
+}
+interface BuildConfig {
+  cwd?: string | URL;
+  entries?: (BuildEntry | string)[];
+  hooks?: BuildHooks;
+}
+//#endregion
+export { BuildConfig, BuildEntry, BundleEntry, TransformEntry };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { build } from "./_chunks/build-Dn4aJvxA.mjs";
+import { consola } from "consola";
+import { parseArgs } from "node:util";
+import { loadConfig } from "c12";
+
+//#region src/cli.ts
+const args = parseArgs({
+	args: process.argv.slice(2),
+	allowPositionals: true,
+	options: {
+		dir: {
+			type: "string",
+			default: "."
+		},
+		stub: {
+			type: "boolean",
+			default: false
+		}
+	}
+});
+const { config = {} } = await loadConfig({
+	name: "robuild",
+	configFile: "build.config",
+	cwd: args.values.dir
+});
+const rawEntries = args.positionals.length > 0 ? args.positionals : config.entries || [];
+const entries = rawEntries.map((entry) => {
+	if (typeof entry === "string") {
+		const [input, outDir] = entry.split(":");
+		return input.endsWith("/") ? {
+			type: "transform",
+			input,
+			outDir
+		} : {
+			type: "bundle",
+			input: input.split(","),
+			outDir
+		};
+	}
+	return entry;
+});
+if (args.values.stub) for (const entry of entries) entry.stub = true;
+if (rawEntries.length === 0) {
+	consola.error("No build entries specified.");
+	process.exit(1);
+}
+await build({
+	cwd: args.values.dir,
+	...config,
+	entries
+});
+
+//#endregion

package/dist/config.d.mts

@@ -0,0 +1,6 @@
+import { BuildConfig } from "./_chunks/types-1AA9vjTS.mjs";
+
+//#region src/config.d.ts
+declare function defineBuildConfig(config: BuildConfig): BuildConfig;
+//#endregion
+export { defineBuildConfig };

package/dist/config.mjs

@@ -0,0 +1,7 @@
+//#region src/config.ts
+function defineBuildConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineBuildConfig };

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+import { BuildConfig, BuildEntry, BundleEntry, TransformEntry } from "./_chunks/types-1AA9vjTS.mjs";
+
+//#region src/build.d.ts
+
+/**
+* Build dist/ from src/
+*/
+declare function build(config: BuildConfig): Promise<void>;
+//#endregion
+export { BuildConfig, BuildEntry, BundleEntry, TransformEntry, build };

package/dist/index.mjs

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

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "robuild",
+  "type": "module",
+  "version": "0.0.2",
+  "packageManager": "pnpm@10.11.1",
+  "description": "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc",
+  "license": "MIT",
+  "repository": "Sunny-117/robuild",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./config": "./dist/config.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "bin": "./dist/cli.mjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm robuild",
+    "dev": "pnpm vitest",
+    "lint": "eslint .",
+    "lint:fix": "automd && eslint . --fix",
+    "robuild": "esno src/cli.ts",
+    "prepack": "pnpm build",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  },
+  "dependencies": {
+    "c12": "^3.0.4",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "exsolve": "^1.0.5",
+    "magic-string": "^0.30.17",
+    "oxc-minify": "^0.72.3",
+    "oxc-parser": "^0.72.3",
+    "oxc-transform": "^0.72.3",
+    "pretty-bytes": "^7.0.0",
+    "rolldown": "1.0.0-beta.12",
+    "rolldown-plugin-dts": "^0.13.8",
+    "tinyglobby": "^0.2.14"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^4.17.0",
+    "@types/node": "^22.15.30",
+    "@vitest/coverage-v8": "^3.2.2",
+    "automd": "^0.4.0",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.28.0",
+    "esno": "^4.8.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.2"
+  }
+}