robuild 0.0.6 → 0.0.8

package/dist/_chunks/build-DuPhfTzX.mjs

@@ -1,563 +0,0 @@
-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 { parseSync } 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 { transform } from "oxc-transform";
-import { glob } from "tinyglobby";
-import { watch } from "chokidar";
-
-//#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 = 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, /* @__PURE__ */ 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 = 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 = 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/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(watchOptions);
-	consola.info(`👀 Starting watch mode...`);
-	consola.info(`📁 Watching: ${colors.dim(watchPatterns.join(", "))}`);
-	if (ignorePatterns.length > 0) consola.info(`🚫 Ignoring: ${colors.dim(ignorePatterns.join(", "))}`);
-	const delay = watchOptions.delay ?? 100;
-	if (delay > 0) consola.info(`⏱️  Rebuild delay: ${colors.dim(`${delay}ms`)}`);
-	const watcher = watch(watchPatterns, {
-		ignored: ignorePatterns,
-		ignoreInitial: watchOptions.ignoreInitial ?? false,
-		persistent: true,
-		followSymlinks: false,
-		cwd: ctx.pkgDir
-	});
-	watcher.on("change", (path) => handleFileChange(watchCtx, path, "changed"));
-	watcher.on("add", (path) => {
-		if (watchOptions.watchNewFiles !== false) handleFileChange(watchCtx, path, "added");
-	});
-	watcher.on("unlink", (path) => handleFileChange(watchCtx, path, "removed"));
-	watcher.on("error", (error) => {
-		consola.error("❌ Watch error:", error);
-	});
-	if (process.env.DEBUG) {
-		watcher.on("addDir", (path) => consola.debug(`📁 Directory added: ${path}`));
-		watcher.on("unlinkDir", (path) => consola.debug(`📁 Directory removed: ${path}`));
-	}
-	await new Promise((resolve$1) => {
-		watcher.on("ready", () => {
-			const watchedPaths = watcher.getWatched();
-			const totalFiles = Object.values(watchedPaths).reduce((sum, files) => sum + files.length, 0);
-			consola.success(`🚀 Watch mode ready - watching ${totalFiles} files`);
-			consola.info(`💡 Press ${colors.cyan("Ctrl+C")} to stop watching`);
-			resolve$1();
-		});
-	});
-	return () => {
-		if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
-		return watcher.close();
-	};
-}
-/**
-* Handle file change events
-*/
-function handleFileChange(watchCtx, filePath, changeType) {
-	const { config, ctx } = watchCtx;
-	const watchOptions = config.watch || {};
-	const delay = watchOptions.delay ?? 100;
-	const relativePath = relative(ctx.pkgDir, join(ctx.pkgDir, filePath));
-	const formattedPath = fmtPath(relativePath);
-	const changeIcon = changeType === "changed" ? "📝" : changeType === "added" ? "➕" : "➖";
-	consola.info(`${changeIcon} ${colors.cyan(formattedPath)} ${changeType}`);
-	if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
-	watchCtx.pendingRebuild = true;
-	watchCtx.rebuildTimer = setTimeout(() => {
-		triggerRebuild(watchCtx);
-	}, delay);
-}
-/**
-* Trigger a rebuild
-*/
-async function triggerRebuild(watchCtx) {
-	const { config, buildFn } = watchCtx;
-	if (watchCtx.isBuilding) return;
-	if (!watchCtx.pendingRebuild) return;
-	watchCtx.isBuilding = true;
-	watchCtx.pendingRebuild = false;
-	try {
-		consola.info(`🔄 Rebuilding...`);
-		const start = Date.now();
-		const buildConfig = {
-			...config,
-			watch: {
-				...config.watch,
-				enabled: false
-			}
-		};
-		await buildFn(buildConfig);
-		const duration = Date.now() - start;
-		consola.success(`✅ Rebuild completed in ${duration}ms`);
-	} catch (error) {
-		consola.error("❌ Rebuild failed:");
-		if (error instanceof Error) {
-			consola.error(`   ${error.message}`);
-			if (process.env.DEBUG && error.stack) consola.debug(error.stack);
-		} else consola.error(`   ${String(error)}`);
-		consola.info("👀 Still watching for changes...");
-	} finally {
-		watchCtx.isBuilding = false;
-		if (watchCtx.pendingRebuild) setTimeout(() => triggerRebuild(watchCtx), watchCtx.config.watch?.delay ?? 100);
-	}
-}
-/**
-* Get patterns for files to watch
-*/
-async function getWatchPatterns(config, ctx, watchOptions) {
-	if (watchOptions.include && watchOptions.include.length > 0) return watchOptions.include;
-	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}/**/*`);
-		}
-	}
-	if (patterns.length === 0) patterns.push("src/**/*", "*.ts", "*.js", "*.mjs", "*.json");
-	return [...new Set(patterns)];
-}
-/**
-* Get patterns for files to ignore
-*/
-function getIgnorePatterns(watchOptions) {
-	const defaultIgnores = [
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/build/**",
-		"**/coverage/**",
-		"**/.git/**",
-		"**/.DS_Store",
-		"**/Thumbs.db",
-		"**/*.log",
-		"**/tmp/**",
-		"**/temp/**"
-	];
-	if (watchOptions.exclude && watchOptions.exclude.length > 0) return [...defaultIgnores, ...watchOptions.exclude];
-	return defaultIgnores;
-}
-
-//#endregion
-//#region src/build.ts
-/**
-* Build dist/ from src/
-*/
-async function build(config) {
-	const pkgDir = normalizePath(config.cwd);
-	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
-	const ctx = {
-		pkg,
-		pkgDir
-	};
-	if (config.watch?.enabled) {
-		consola.log(`👀 Starting watch mode for \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
-		await performBuild(config, ctx);
-		const stopWatch = await startWatch(config, ctx, build);
-		const cleanup = () => {
-			consola.info("🛑 Stopping watch mode...");
-			stopWatch();
-			process.exit(0);
-		};
-		process.on("SIGINT", cleanup);
-		process.on("SIGTERM", cleanup);
-		return new Promise(() => {});
-	}
-	consola.log(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
-	await performBuild(config, ctx);
-}
-/**
-* Perform the actual build process
-*/
-async function performBuild(config, ctx) {
-	const start = Date.now();
-	const hooks = config.hooks || {};
-	await hooks.start?.(ctx);
-	const entries = (config.entries || []).map((rawEntry) => {
-		let entry;
-		if (typeof rawEntry === "string") {
-			const [input, outDir] = rawEntry.split(":");
-			entry = input.endsWith("/") ? {
-				type: "transform",
-				input,
-				outDir
-			} : {
-				type: "bundle",
-				input: input.split(","),
-				outDir
-			};
-		} else entry = rawEntry;
-		if (!entry.input) throw new Error(`Build entry missing \`input\`: ${JSON.stringify(entry, null, 2)}`);
-		entry = { ...entry };
-		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
-		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, ctx.pkgDir)) : normalizePath(entry.input, ctx.pkgDir);
-		return entry;
-	});
-	await hooks.entries?.(entries, ctx);
-	const outDirs = [];
-	for (const outDir of entries.map((e) => e.outDir).sort()) if (!outDirs.some((dir) => outDir.startsWith(dir))) outDirs.push(outDir);
-	for (const 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/config-BZW4dLYD.d.mts

@@ -1,138 +0,0 @@
-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 WatchOptions {
-  /**
-  * Enable watch mode.
-  *
-  * Defaults to `false` if not provided.
-  */
-  enabled?: boolean;
-  /**
-  * Glob patterns for files to watch.
-  *
-  * Defaults to watching all source files if not provided.
-  */
-  include?: string[];
-  /**
-  * Glob patterns for files to ignore.
-  *
-  * Defaults to common ignore patterns if not provided.
-  */
-  exclude?: string[];
-  /**
-  * Delay in milliseconds before rebuilding after a file change.
-  *
-  * Defaults to `100` if not provided.
-  */
-  delay?: number;
-  /**
-  * Whether to ignore the initial build when starting watch mode.
-  *
-  * Defaults to `false` if not provided.
-  */
-  ignoreInitial?: boolean;
-  /**
-  * Whether to watch for new files being added.
-  *
-  * Defaults to `true` if not provided.
-  */
-  watchNewFiles?: boolean;
-}
-interface BuildConfig {
-  cwd?: string | URL;
-  entries?: (BuildEntry | string)[];
-  hooks?: BuildHooks;
-  watch?: WatchOptions;
-}
-//#endregion
-//#region src/config.d.ts
-declare function defineConfig(config: BuildConfig): BuildConfig;
-//#endregion
-export { BuildConfig, BuildEntry, BundleEntry, TransformEntry, defineConfig };