webanvil 0.0.6 → 0.0.7

package/dist/_chunks/commands.mjs

@@ -0,0 +1,1867 @@
+import { Module, createRequire, isBuiltin } from "node:module";
+import { defineArgument, defineCommand, defineOption } from "cmdore";
+import { dirname, isAbsolute, join, relative, resolve } from "pathe";
+import { glob } from "tinyglobby";
+import { access, copyFile, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { loadConfig } from "c12";
+import { defu } from "defu";
+import { z } from "zod";
+import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "node:path";
+import { getTsconfig, readTsconfig } from "get-tsconfig";
+import { dts } from "rolldown-plugin-dts";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolvePath } from "mlly";
+import { parse } from "yaml";
+import { resolvePackageJSON } from "pkg-types";
+import { consola } from "consola";
+import { randomUUID } from "node:crypto";
+import { execa } from "execa";
+const entry = defineArgument({
+	name: "entry",
+	description: "Web entry or Node public root; unbundled Node builds emit its reachable graph with preserveModules."
+});
+const filters = defineArgument({
+	name: "filters",
+	description: "Test files or names to run.",
+	variadic: true
+});
+const paths = defineArgument({
+	name: "paths",
+	description: "Files or directories to check.",
+	variadic: true
+});
+const hasFile = async (path) => access(path).then(() => true).catch(() => false);
+const hasToolConfig = async (name, cwd = process.cwd()) => {
+	const files = await readdir(cwd).catch(() => []);
+	return [
+		"js",
+		"mjs",
+		"cjs",
+		"ts",
+		"mts",
+		"cts"
+	].some((extension) => files.includes(`${name}.config.${extension}`));
+};
+const hasOxcConfig = (name, cwd = process.cwd()) => hasFile(join(cwd, name === "oxfmt" ? ".oxfmtrc.json" : ".oxlintrc.json"));
+const NODE_PLUGIN_ERROR = "Node builds require plugins created with definePlugin()";
+const definePlugin = (plugin, options) => ({
+	rolldown: () => plugin.rolldown(options),
+	vite: () => plugin.vite(options)
+});
+const isUnpluginAdapter = (plugin) => typeof plugin === "object" && plugin !== null && "rolldown" in plugin && typeof plugin.rolldown === "function" && "vite" in plugin && typeof plugin.vite === "function";
+const isWebAnvilPlugin = (plugin) => Array.isArray(plugin) || typeof plugin === "function" || typeof plugin === "object" && plugin !== null && "name" in plugin || isUnpluginAdapter(plugin);
+const resolveRolldownPlugins = (plugins) => plugins.flatMap((plugin) => {
+	if (!isUnpluginAdapter(plugin)) throw new Error(NODE_PLUGIN_ERROR);
+	return plugin.rolldown();
+});
+const resolveVitePlugins = (plugins) => plugins.map((plugin) => isUnpluginAdapter(plugin) ? plugin.vite() : plugin);
+const copyMappingSchema = z.strictObject({
+	from: z.string().min(1),
+	to: z.string().min(1)
+});
+const legacyPlatformTarget = (target) => (typeof target === "string" ? [target] : target).find((value) => value === "browser" || value === "neutral");
+const assertSyntaxTarget = (target) => {
+	if (target === void 0) return;
+	const legacy = legacyPlatformTarget(target);
+	if (legacy !== void 0) throw new Error(`build.target no longer selects a platform; use build.platform: "${legacy}" instead`);
+};
+const syntaxTargetSchema = z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).superRefine((target, context) => {
+	const legacy = legacyPlatformTarget(target);
+	if (legacy !== void 0) context.addIssue({
+		code: "custom",
+		message: `build.target no longer selects a platform; use build.platform: "${legacy}" instead`
+	});
+});
+const nativeConfigSchema = () => z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value), "Expected a configuration object");
+const buildConfigSchema = z.strictObject({
+	bundle: z.boolean().optional(),
+	mode: z.enum(["web", "node"]).optional(),
+	entry: z.string().min(1).optional(),
+	entries: z.record(z.string().min(1), z.string().min(1)).optional(),
+	outDir: z.string().min(1).optional(),
+	declaration: z.union([z.boolean(), nativeConfigSchema()]).optional(),
+	sourcemap: z.boolean().optional(),
+	minify: z.boolean().optional(),
+	copy: z.array(copyMappingSchema).optional(),
+	formats: z.array(z.enum(["esm", "cjs"])).min(1).optional(),
+	platform: z.enum([
+		"node",
+		"browser",
+		"neutral"
+	]).optional(),
+	target: syntaxTargetSchema.optional()
+});
+const formatConfigSchema = nativeConfigSchema();
+const lintConfigSchema = nativeConfigSchema();
+const rolldownConfigSchema = nativeConfigSchema();
+const testConfigSchema = nativeConfigSchema();
+const viteConfigSchema = nativeConfigSchema();
+const pluginSchema = z.custom(isWebAnvilPlugin, "Expected a Vite plugin or a WebAnvil plugin created with definePlugin()");
+const userConfigSchema = z.strictObject({
+	build: buildConfigSchema.optional(),
+	format: formatConfigSchema.optional(),
+	lint: lintConfigSchema.optional(),
+	rolldown: rolldownConfigSchema.optional(),
+	test: testConfigSchema.optional(),
+	vite: viteConfigSchema.optional(),
+	plugins: z.array(pluginSchema).optional()
+});
+const effectiveUserConfigSchema = userConfigSchema.superRefine((config, context) => {
+	const build = config.build ?? {};
+	if (build.entries !== void 0 && build.mode !== "node") context.addIssue({
+		code: "custom",
+		path: ["build", "entries"],
+		message: "build.entries is only available in Node mode"
+	});
+	if (build.mode === "web" && build.platform !== void 0) context.addIssue({
+		code: "custom",
+		path: ["build", "platform"],
+		message: "Web builds do not accept build.platform"
+	});
+	if (build.mode === "node") {
+		for (const [index, plugin] of (config.plugins ?? []).entries()) if (!isUnpluginAdapter(plugin)) context.addIssue({
+			code: "custom",
+			path: ["plugins", index],
+			message: NODE_PLUGIN_ERROR
+		});
+	}
+});
+const defaultConfig = {
+	build: {
+		mode: "node",
+		entry: "src/index.ts",
+		outDir: "dist"
+	},
+	test: { environment: "node" }
+};
+const toCommandArguments = (config) => Object.fromEntries(Object.entries(config).filter(([, value]) => value !== void 0).map(([key, value]) => [key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`), value]));
+const defined = (arguments_) => Object.fromEntries(Object.entries(arguments_).filter(([, value]) => value !== void 0));
+const defineConfig = (config) => config;
+const loadConfig$1 = async (cwd = process.cwd()) => {
+	const { config, configFile } = await loadConfig({
+		name: "webanvil",
+		cwd,
+		configFile: "webanvil.config",
+		packageJson: false,
+		rcFile: false
+	});
+	return {
+		config: userConfigSchema.parse(defu(config, defaultConfig)),
+		configFile
+	};
+};
+const resolveEffectiveBuildConfig = (config, overrides, explicitEntry) => {
+	const build = {
+		...config.build,
+		...defined(overrides)
+	};
+	if (explicitEntry) delete build.entries;
+	return effectiveUserConfigSchema.parse({
+		...config,
+		build
+	}).build ?? {};
+};
+const withConfig = (select, run) => async (arguments_) => {
+	const { config } = await loadConfig$1();
+	const selectedConfig = select(config) ?? {};
+	return run({
+		...toCommandArguments(selectedConfig),
+		...defined(arguments_)
+	}, selectedConfig, config, arguments_);
+};
+const path = (cwd) => resolve(cwd, ".webanvil", "buildinfo.json");
+const relativeOutput = (file, cwd) => {
+	const output = relative(cwd, resolve(cwd, file));
+	if (output === "" || output === ".." || output.startsWith("../") || isAbsolute(output)) throw new Error(`Invalid build output: ${file}`);
+	return output;
+};
+const assertSafeRemoval = async (file, cwd) => {
+	let directory = dirname(resolve(cwd, relativeOutput(file, cwd)));
+	while (directory !== resolve(cwd)) {
+		try {
+			if ((await lstat(directory)).isSymbolicLink()) throw new Error(`Refusing to remove output through symbolic link: ${file}`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		directory = dirname(directory);
+	}
+};
+const removeBuildOutputs = async (output, cwd = process.cwd()) => {
+	await Promise.all(output.map(async (file) => {
+		await assertSafeRemoval(file, cwd);
+		await rm(resolve(cwd, file), { force: true });
+	}));
+};
+const readBuildInfo = async (cwd = process.cwd()) => {
+	try {
+		const value = JSON.parse(await readFile(path(cwd), "utf8"));
+		if (typeof value !== "object" || value === null || !("output" in value) || !Array.isArray(value.output) || !value.output.every((file) => typeof file === "string")) throw new Error("Expected { output: string[] }");
+		return { output: value.output.map((file) => relativeOutput(file, cwd)) };
+	} catch (error) {
+		if (error.code === "ENOENT") return { output: [] };
+		throw new Error(`Invalid .webanvil/buildinfo.json: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+const writeBuildInfo = async (output, cwd = process.cwd()) => {
+	const file = path(cwd);
+	const value = { output: [...new Set(output.map((entry) => relativeOutput(entry, cwd)))].sort() };
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(`${file}.tmp`, `${JSON.stringify(value, null, 2)}\n`);
+	await rename(`${file}.tmp`, file);
+};
+const removeOutputsIn = async (outDir, cwd = process.cwd()) => {
+	const info = await readBuildInfo(cwd);
+	const directory = resolve(cwd, outDir);
+	const output = info.output.filter((file) => {
+		const target = resolve(cwd, file);
+		return target !== directory && !relative(directory, target).startsWith("../");
+	});
+	await removeBuildOutputs(output, cwd);
+	await Promise.all([...new Set(output.map((file) => dirname(resolve(cwd, file))))].map(async (directory) => {
+		while (directory !== resolve(cwd) && directory !== resolve(cwd, outDir)) {
+			try {
+				await rmdir(directory);
+			} catch (error) {
+				if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+				break;
+			}
+			directory = dirname(directory);
+		}
+	}));
+	return { output: info.output.filter((file) => !output.includes(file)) };
+};
+const clearBuildInfo = (cwd = process.cwd()) => writeBuildInfo([], cwd);
+const { satisfies } = createRequire(import.meta.url)("semver");
+const supportedTools = {
+	vite: {
+		packageName: "vite",
+		range: ">=8.1.5 <9"
+	},
+	vitest: {
+		packageName: "vitest",
+		range: ">=4.1.10 <5"
+	},
+	rolldown: {
+		packageName: "rolldown",
+		range: ">=1.2.0 <2"
+	},
+	oxlint: {
+		packageName: "oxlint",
+		range: ">=1.75.0 <2",
+		bin: "oxlint"
+	},
+	oxfmt: {
+		packageName: "oxfmt",
+		range: ">=0.60.0 <0.61",
+		bin: "oxfmt"
+	},
+	typescript: {
+		packageName: "typescript",
+		range: ">=5 <7"
+	},
+	"typescript-native": {
+		packageName: "@typescript/native-preview",
+		range: ">=7.0.0-dev.20260707.2 <7.0.0",
+		bin: "tsgo"
+	}
+};
+const dependencyFields = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+const readManifest = async (path) => {
+	const contents = await readFile(path, "utf8");
+	const manifest = JSON.parse(contents);
+	if (manifest === null || typeof manifest !== "object" || manifest instanceof Array) throw new Error(`Invalid package manifest at ${path}`);
+	return manifest;
+};
+const hasOwnDeclaration = (manifest, packageName) => dependencyFields.some((field) => {
+	const dependencies = manifest[field];
+	return dependencies !== null && typeof dependencies === "object" && !Array.isArray(dependencies) && Object.hasOwn(dependencies, packageName);
+});
+const parentDirectories = function* (start) {
+	let directory = resolve$1(start);
+	while (true) {
+		yield directory;
+		const parent = dirname$1(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+};
+const findNearestManifest = async (cwd) => {
+	for (const directory of parentDirectories(cwd)) {
+		const path = join$1(directory, "package.json");
+		try {
+			await access(path);
+			return {
+				directory,
+				path
+			};
+		} catch {}
+	}
+};
+const manifestWorkspacePatterns = (manifest) => {
+	if (Array.isArray(manifest.workspaces)) return manifest.workspaces.filter((pattern) => typeof pattern === "string");
+	if (manifest.workspaces !== null && typeof manifest.workspaces === "object" && !Array.isArray(manifest.workspaces) && Array.isArray(manifest.workspaces.packages)) return manifest.workspaces.packages.filter((pattern) => typeof pattern === "string");
+	return [];
+};
+const pnpmWorkspacePatterns = async (directory) => {
+	const path = join$1(directory, "pnpm-workspace.yaml");
+	let contents;
+	try {
+		contents = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	let manifest;
+	try {
+		manifest = parse(contents);
+	} catch (error) {
+		throw new Error(`Invalid pnpm workspace manifest at ${path}`, { cause: error });
+	}
+	if (manifest === null || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error(`Invalid pnpm workspace manifest at ${path}: expected a mapping`);
+	const packages = manifest.packages;
+	if (packages === void 0) return [];
+	if (!Array.isArray(packages) || packages.some((pattern) => typeof pattern !== "string")) throw new Error(`Invalid pnpm workspace manifest at ${path}: packages must be an array of strings`);
+	return packages;
+};
+const isWorkspaceMember = async (manifest, workspaceDirectory, projectDirectory) => {
+	const patterns = [...manifestWorkspacePatterns(manifest), ...await pnpmWorkspacePatterns(workspaceDirectory)];
+	if (patterns.length === 0) return false;
+	const members = await glob(patterns, {
+		absolute: true,
+		cwd: workspaceDirectory,
+		onlyDirectories: true
+	});
+	const project = resolve$1(projectDirectory);
+	return members.some((member) => resolve$1(member) === project);
+};
+const findDeclaration = async (cwd, packageName) => {
+	const project = await findNearestManifest(cwd);
+	if (project !== void 0) {
+		const manifest = await readManifest(project.path);
+		if (hasOwnDeclaration(manifest, packageName)) return project;
+	}
+	const workspaceSearchRoot = project === void 0 ? cwd : dirname$1(project.directory);
+	for (const directory of parentDirectories(workspaceSearchRoot)) {
+		const path = join$1(directory, "package.json");
+		let manifest;
+		try {
+			manifest = await readManifest(path);
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		if (project !== void 0 && await isWorkspaceMember(manifest, directory, project.directory) && hasOwnDeclaration(manifest, packageName)) return {
+			directory,
+			path
+		};
+	}
+};
+const findContainingManifest = async (entryPath) => {
+	for (const directory of parentDirectories(dirname$1(entryPath))) {
+		const path = join$1(directory, "package.json");
+		try {
+			await access(path);
+			return path;
+		} catch {}
+	}
+	throw new Error(`Could not find the package manifest containing ${entryPath}`);
+};
+const resolveInstalledManifest = (packageName, anchor) => {
+	const require = createRequire(join$1(anchor, "package.json"));
+	try {
+		return require.resolve(`${packageName}/package.json`);
+	} catch (error) {
+		if (error.code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") throw error;
+		return require.resolve(packageName);
+	}
+};
+const resolveDeclaredPackage = async (packageName, cwd = process.cwd()) => {
+	const declaration = await findDeclaration(cwd, packageName);
+	if (declaration === void 0) throw new Error(`${packageName} must be declared in the active project or workspace package.json before WebAnvil can use it`);
+	let resolvedPath;
+	try {
+		resolvedPath = resolveInstalledManifest(packageName, declaration.directory);
+	} catch (error) {
+		if (error.code === "MODULE_NOT_FOUND") throw new Error(`${packageName} is declared by ${declaration.path} but is not installed`, { cause: error });
+		throw error;
+	}
+	const manifestPath = resolvedPath.endsWith("package.json") ? resolvedPath : await findContainingManifest(resolvedPath);
+	const manifest = await readManifest(manifestPath);
+	if (manifest.name !== packageName || typeof manifest.version !== "string") throw new Error(`The resolved ${packageName} package at ${dirname$1(manifestPath)} has invalid package metadata`);
+	return {
+		declarationDirectory: declaration.directory,
+		packageRoot: dirname$1(manifestPath),
+		version: manifest.version
+	};
+};
+const normalizeSubpath = (subpath) => subpath.replace(/^\.?\//, "");
+const resolveExecutable = async (definition, manifest, packageRoot) => {
+	if (definition.bin === void 0) return;
+	const relativeExecutable = typeof manifest.bin === "string" ? manifest.bin : manifest.bin !== null && typeof manifest.bin === "object" && !Array.isArray(manifest.bin) ? manifest.bin[definition.bin] : void 0;
+	if (typeof relativeExecutable !== "string") throw new Error(`${definition.packageName} does not provide its expected ${definition.bin} executable`);
+	const executable = resolve$1(packageRoot, relativeExecutable);
+	const packageRelativePath = relative$1(packageRoot, executable);
+	if (packageRelativePath.startsWith("..") || isAbsolute$1(packageRelativePath)) throw new Error(`${definition.packageName} has an invalid ${definition.bin} executable path`);
+	try {
+		await access(executable);
+	} catch {
+		throw new Error(`${definition.packageName}'s ${definition.bin} executable is missing at ${executable}`);
+	}
+	return executable;
+};
+const loadResolvedTool = async (name, definition, anchor, source) => {
+	let resolvedPath;
+	try {
+		resolvedPath = resolveInstalledManifest(definition.packageName, anchor);
+	} catch (error) {
+		if (error.code === "MODULE_NOT_FOUND") throw new Error(`${definition.packageName} is declared by ${join$1(anchor, "package.json")} but is not installed`, { cause: error });
+		throw error;
+	}
+	const manifestPath = resolvedPath.endsWith("package.json") ? resolvedPath : await findContainingManifest(resolvedPath);
+	const packageRoot = dirname$1(manifestPath);
+	const manifest = await readManifest(manifestPath);
+	if (manifest.name !== definition.packageName) throw new Error(`Expected ${definition.packageName} at ${packageRoot}, but its package manifest identifies as ${String(manifest.name)}`);
+	if (typeof manifest.version !== "string") throw new Error(`${definition.packageName} at ${packageRoot} does not declare a valid version`);
+	if (!satisfies(manifest.version, definition.range)) throw new Error(`${definition.packageName} ${manifest.version} is incompatible with WebAnvil; supported versions are ${definition.range}`);
+	const importPackage = async (subpath) => {
+		return import(pathToFileURL(await resolvePath(subpath === void 0 || subpath === "" ? definition.packageName : `${definition.packageName}/${normalizeSubpath(subpath)}`, {
+			conditions: [
+				"node",
+				"import",
+				"default"
+			],
+			url: pathToFileURL(manifestPath)
+		})).href);
+	};
+	return {
+		name,
+		packageName: definition.packageName,
+		version: manifest.version,
+		source,
+		packageRoot,
+		import: importPackage,
+		executable: await resolveExecutable(definition, manifest, packageRoot)
+	};
+};
+var Toolchain = class {
+	cwd;
+	#tools = /* @__PURE__ */ new Map();
+	constructor(cwd = process.cwd()) {
+		this.cwd = resolve$1(cwd);
+	}
+	resolve(name) {
+		const existing = this.#tools.get(name);
+		if (existing !== void 0) return existing;
+		const selected = this.#resolve(name);
+		this.#tools.set(name, selected);
+		return selected;
+	}
+	async #resolve(name) {
+		const definition = supportedTools[name];
+		const declaration = await findDeclaration(this.cwd, definition.packageName);
+		if (declaration !== void 0) return loadResolvedTool(name, definition, declaration.directory, "project");
+		const webanvilPackageRoot = dirname$1(await findContainingManifest(fileURLToPath(import.meta.url)));
+		return loadResolvedTool(name, definition, webanvilPackageRoot, "webanvil");
+	}
+};
+const formatResolvedTool = (tool) => `${tool.packageName} ${tool.version} (${tool.source})`;
+const declarationDefaults = {
+	generator: "tsc",
+	incremental: false,
+	newContext: true,
+	parallel: false
+};
+let compilerIdentity;
+let setupTail = Promise.resolve();
+const serializeSetup = async (setup) => {
+	const previous = setupTail;
+	let release;
+	setupTail = new Promise((resolvePromise) => {
+		release = resolvePromise;
+	});
+	await previous;
+	try {
+		return await setup();
+	} finally {
+		release();
+	}
+};
+const compilerPlugins = (cwd, config) => {
+	if (config.tsconfig === false) return { plugins: (config.compilerOptions?.plugins ?? []).filter((plugin) => typeof plugin.transform === "string") };
+	const result = typeof config.tsconfig === "string" ? readTsconfig(resolve$1(cwd, config.tsconfig)) : getTsconfig(cwd);
+	const configured = (result?.config.compilerOptions)?.plugins ?? [];
+	return {
+		plugins: (config.compilerOptions?.plugins ?? configured).filter((plugin) => typeof plugin.transform === "string"),
+		...result === void 0 ? {} : { tsconfigPath: result.path }
+	};
+};
+const packageName = (specifier) => {
+	if (specifier.startsWith(".") || isAbsolute$1(specifier)) return;
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+};
+const assertTransformPackages = async (plugins, cwd) => {
+	for (const plugin of plugins) {
+		if (typeof plugin.transform !== "string") continue;
+		const name = packageName(plugin.transform);
+		if (name === void 0) continue;
+		const declared = await resolveDeclaredPackage(name, cwd);
+		const require = createRequire(join$1(declared.declarationDirectory, "package.json"));
+		let resolvedTransform;
+		try {
+			resolvedTransform = require.resolve(plugin.transform);
+		} catch (error) {
+			throw new Error(`TypeScript declaration transform ${plugin.transform} is declared but cannot be resolved`, { cause: error });
+		}
+		const packageRelative = relative$1(declared.packageRoot, resolvedTransform);
+		if (packageRelative.startsWith("..") || isAbsolute$1(packageRelative)) throw new Error(`TypeScript declaration transform ${plugin.transform} resolved outside its declared ${name} package`);
+	}
+};
+const typescriptEntry = (tool) => createRequire(join$1(tool.packageRoot, "package.json")).resolve("typescript");
+const patchedCompilerEntry = async (typescript, cwd, plugins) => {
+	if (plugins.length === 0) return typescriptEntry(typescript);
+	await assertTransformPackages(plugins, cwd);
+	const tsPatch = await resolveDeclaredPackage("ts-patch", cwd);
+	const require = createRequire(join$1(tsPatch.declarationDirectory, "package.json"));
+	let patchedEntry;
+	try {
+		patchedEntry = require.resolve("ts-patch/compiler");
+	} catch (error) {
+		throw new Error("ts-patch is declared but its patched compiler entry cannot be resolved", { cause: error });
+	}
+	const patchTypescript = await realpath(createRequire(join$1(tsPatch.packageRoot, "package.json")).resolve("typescript"));
+	const selectedTypescript = await realpath(typescriptEntry(typescript));
+	if (patchTypescript !== selectedTypescript) throw new Error(`ts-patch resolves TypeScript at ${patchTypescript}, but WebAnvil selected ${selectedTypescript}; install both from the same project or workspace`);
+	const patched = require(patchedEntry);
+	if (patched.version !== typescript.version) throw new Error(`ts-patch compiler ${String(patched.version)} does not match selected TypeScript ${typescript.version}`);
+	return patchedEntry;
+};
+const withCompilerResolution = (entry, run) => {
+	const module = Module;
+	const original = module._resolveFilename;
+	module._resolveFilename = function(request, parent, isMain, options) {
+		if (request === "typescript" && parent?.filename?.includes("rolldown-plugin-dts")) return entry;
+		return original.call(this, request, parent, isMain, options);
+	};
+	try {
+		return run();
+	} finally {
+		module._resolveFilename = original;
+	}
+};
+const assertCompilerIdentity = (selected) => {
+	if (compilerIdentity === void 0) {
+		compilerIdentity = selected;
+		return;
+	}
+	if (compilerIdentity.realpath === selected.realpath && compilerIdentity.version === selected.version) return;
+	throw new Error(`rolldown-plugin-dts already initialized TypeScript ${compilerIdentity.version} from ${compilerIdentity.realpath}; this process cannot switch to TypeScript ${selected.version} from ${selected.realpath}. Run builds that require different TypeScript compilers in separate processes.`);
+};
+const withoutImplicitIncremental = (config) => {
+	const compilerOptions = config.compilerOptions;
+	if (config.incremental === true || compilerOptions?.incremental === true || typeof compilerOptions?.tsBuildInfoFile === "string") return config;
+	return {
+		...config,
+		incremental: false,
+		compilerOptions: {
+			...compilerOptions,
+			incremental: false,
+			tsBuildInfoFile: void 0
+		}
+	};
+};
+const createDeclarationPlugins = async (declaration, cwd, toolchain, emitDtsOnly) => serializeSetup(async () => {
+	const configured = withoutImplicitIncremental(declaration === true ? {} : declaration);
+	const generator = configured.generator ?? declarationDefaults.generator;
+	const { plugins, tsconfigPath } = compilerPlugins(cwd, configured);
+	if (plugins.length > 0 && generator !== "tsc") throw new Error(`TypeScript declaration transforms from ${tsconfigPath ?? "compilerOptions"} require build.declaration.generator "tsc"; ${generator} cannot apply TypeScript emit transforms`);
+	const options = {
+		...declarationDefaults,
+		...configured,
+		cwd,
+		emitDtsOnly,
+		generator,
+		parallel: false
+	};
+	if (generator === "tsgo") {
+		const tsgo = await toolchain.resolve("typescript-native");
+		if (tsgo.executable === void 0) throw new Error(`${tsgo.packageName} does not provide the tsgo executable required for declarations`);
+		options.tsgo = {
+			...typeof configured.tsgo === "object" ? configured.tsgo : {},
+			path: tsgo.executable
+		};
+	}
+	if (generator !== "tsc") return dts(options);
+	const typescript = await toolchain.resolve("typescript");
+	const compilerEntry = await patchedCompilerEntry(typescript, cwd, plugins);
+	const selected = {
+		realpath: await realpath(compilerEntry),
+		version: typescript.version
+	};
+	assertCompilerIdentity(selected);
+	return withCompilerResolution(compilerEntry, () => dts(options));
+});
+const dependencyStoreSegments = [
+	"/node_modules/",
+	"/.pnpm/",
+	"/.yarn/cache/",
+	"/.yarn/berry/cache/",
+	"/.bun/install/cache/"
+];
+const cleanId = (id) => id.replaceAll("\\", "/").split(/[?#]/, 1)[0];
+const isInstalledPackagePath = (id, cwd = process.cwd()) => {
+	const path = cleanId(id);
+	if (dependencyStoreSegments.some((segment) => path.includes(segment))) return true;
+	const projectRelative = relative(cwd, path);
+	return (projectRelative === ".." || projectRelative.startsWith("../")) && (path.includes("/pnpm/store/") || path.includes("/bun/install/"));
+};
+const cacheKey = (source, importer) => `${importer ?? ""}\0${source}`;
+const projectExternalPlugin = (cwd = process.cwd()) => {
+	const resolutionCache = /* @__PURE__ */ new Map();
+	return {
+		name: "webanvil-project-externals",
+		buildStart() {
+			resolutionCache.clear();
+		},
+		resolveId: {
+			order: "pre",
+			async handler(source, importer, options) {
+				if (isBuiltin(source)) return {
+					id: source,
+					external: true
+				};
+				if (source.startsWith(".") || isAbsolute(source) || source.startsWith("\0")) return null;
+				const key = cacheKey(source, importer);
+				let pending = resolutionCache.get(key);
+				if (pending === void 0) {
+					pending = this.resolve(source, importer, {
+						...options,
+						skipSelf: true
+					});
+					resolutionCache.set(key, pending);
+				}
+				const resolved = await pending;
+				if (resolved === null) this.error(`Could not resolve "${source}"${importer === void 0 ? "" : ` from ${importer}`}`);
+				if (resolved.external) return resolved;
+				return isInstalledPackagePath(resolved.id, cwd) ? {
+					id: source,
+					external: true
+				} : resolved;
+			}
+		}
+	};
+};
+const sourceExtensions = [
+	".cts",
+	".mts",
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+const rolldownRuntimePlugin = () => ({
+	name: "webanvil-rolldown-runtime",
+	resolveId: {
+		order: "pre",
+		handler(source, importer) {
+			if (source !== "node:module" || importer !== "\0rolldown/runtime.js") return null;
+			return {
+				id: source,
+				external: true,
+				moduleSideEffects: false
+			};
+		}
+	}
+});
+const withoutExtension = (path) => {
+	const extension = sourceExtensions.find((candidate) => path.endsWith(candidate));
+	return extension === void 0 ? path : path.slice(0, -extension.length);
+};
+const entryName = (subpath) => subpath === "." ? "index" : subpath.replace(/^\.\//, "");
+const defaultEntryName = (entry, cwd) => withoutExtension(relative(cwd, resolve(cwd, entry))).replace(/^src\//, "");
+const resolvePublicInputs = (cwd, entry, entries) => {
+	if (entries === void 0) return { [defaultEntryName(entry, cwd)]: resolve(cwd, entry) };
+	const inputs = {};
+	const names = /* @__PURE__ */ new Map();
+	const sources = /* @__PURE__ */ new Map();
+	for (const [subpath, source] of Object.entries(entries)) {
+		const name = entryName(subpath);
+		const existingName = names.get(name);
+		if (existingName !== void 0) throw new Error(`Node entries ${existingName} and ${subpath} normalize to the same public name: ${name}`);
+		names.set(name, subpath);
+		const resolved = resolve(cwd, source);
+		const existing = sources.get(resolved);
+		if (existing !== void 0) throw new Error(`Node entries ${existing} and ${subpath} resolve to the same source file`);
+		sources.set(resolved, subpath);
+		inputs[name] = resolved;
+	}
+	if (Object.keys(inputs).length === 0) throw new Error("Node build entries cannot be empty");
+	return inputs;
+};
+const commonSourceRoot = (inputs) => {
+	const directories = Object.values(inputs).map(dirname);
+	let root = directories[0];
+	for (const directory of directories.slice(1)) while (relative(root, directory).startsWith("../") || isAbsolute(relative(root, directory))) {
+		const parent = dirname(root);
+		if (parent === root) return root;
+		root = parent;
+	}
+	return root;
+};
+const outputForFormat = (format, native, owned) => ({
+	entryFileNames: format === "esm" ? "[name].js" : "[name].cjs",
+	chunkFileNames: format === "esm" ? "[name]-[hash].js" : "[name]-[hash].cjs",
+	polyfillRequire: false,
+	...native,
+	...owned,
+	cleanDir: false,
+	format: format === "esm" ? "es" : "cjs"
+});
+const nodeOutputPlan = ({ bundle = false, cwd = process.cwd(), declarationPlugins = [], entry, entries, formats = ["esm"], minify, native, outDir, platform = "node", plugins = [], sourcemap, target = "node20" }) => {
+	assertSyntaxTarget(target);
+	const inputs = resolvePublicInputs(cwd, entry, entries);
+	const preserveModulesRoot = commonSourceRoot(inputs);
+	const nativeInput = native?.input ?? {};
+	const nativePlugins = nativeInput.plugins ?? [];
+	const resolveOptions = platform === "neutral" && nativeInput.resolve?.mainFields === void 0 ? {
+		...nativeInput.resolve,
+		mainFields: ["module", "main"]
+	} : nativeInput.resolve;
+	const input = {
+		tsconfig: true,
+		...nativeInput,
+		input: inputs,
+		platform,
+		...resolveOptions === void 0 ? {} : { resolve: resolveOptions },
+		transform: {
+			...typeof nativeInput.transform === "object" ? nativeInput.transform : {},
+			target
+		},
+		plugins: [
+			rolldownRuntimePlugin(),
+			projectExternalPlugin(cwd),
+			...nativePlugins,
+			...plugins,
+			...declarationPlugins
+		]
+	};
+	return {
+		authoredInputs: Object.values(inputs),
+		input,
+		outDir,
+		output: formats.map((format) => outputForFormat(format, native?.output?.[format], {
+			dir: outDir,
+			...minify === void 0 ? {} : { minify },
+			preserveModules: !bundle,
+			...!bundle ? { preserveModulesRoot } : {},
+			...sourcemap === void 0 ? {} : { sourcemap }
+		}))
+	};
+};
+const authoredNodeSources = (plan, outputs) => {
+	const sources = new Set(plan.authoredInputs);
+	for (const output of outputs) for (const file of output.output) {
+		if (file.type !== "chunk") continue;
+		for (const source of Object.keys(file.modules)) if (isAbsolute(source)) sources.add(source);
+		if (file.facadeModuleId !== null && isAbsolute(file.facadeModuleId)) sources.add(file.facadeModuleId);
+	}
+	return [...sources];
+};
+const sourceBytes = (file) => file.type === "chunk" ? file.code : file.source;
+const generatedNodeFiles = (outputs) => {
+	const generated = /* @__PURE__ */ new Map();
+	for (const output of outputs) for (const file of output.output) {
+		const fileName = file.fileName;
+		const source = sourceBytes(file);
+		if (generated.get(fileName) !== void 0) throw new Error(`Rolldown outputs collide at ${fileName}`);
+		generated.set(fileName, {
+			fileName,
+			source
+		});
+	}
+	return [...generated.values()];
+};
+const collectExportConditions = (exports, conditions = /* @__PURE__ */ new Set()) => {
+	if (exports === void 0 || exports === null || typeof exports === "string") return conditions;
+	if (Array.isArray(exports)) {
+		for (const entry of exports) collectExportConditions(entry, conditions);
+		return conditions;
+	}
+	for (const [condition, value] of Object.entries(exports)) {
+		conditions.add(condition);
+		collectExportConditions(value, conditions);
+	}
+	return conditions;
+};
+const inferPackageOutputOptions = (packageJson) => {
+	const conditions = collectExportConditions(packageJson.exports);
+	const formats = [];
+	if (conditions.has("import")) formats.push("esm");
+	if (conditions.has("require")) formats.push("cjs");
+	return {
+		...packageJson.types || conditions.has("types") ? { declaration: true } : {},
+		...formats.length > 0 ? { formats } : {}
+	};
+};
+const resolvePackageOutputOptions = async (options, cwd = process.cwd()) => {
+	const packagePath = await resolvePackageJSON(cwd).catch(() => void 0);
+	const packageJson = packagePath === void 0 ? void 0 : JSON.parse(await readFile(packagePath, "utf8"));
+	const resolved = packageJson === void 0 ? {} : inferPackageOutputOptions(packageJson);
+	if (options.declaration !== void 0) resolved.declaration = options.declaration;
+	if (options.formats !== void 0) resolved.formats = options.formats;
+	return resolved;
+};
+const isInside$1 = (directory, target) => {
+	const path = relative(directory, target);
+	return path === "" || path !== ".." && !path.startsWith("../") && !isAbsolute(path);
+};
+const staticBase = (pattern) => {
+	const parts = pattern.replaceAll("\\", "/").split("/");
+	const index = parts.findIndex((part) => /[*?[\]{}()!]/.test(part));
+	return index === -1 ? dirname(pattern) : parts.slice(0, index).join("/") || ".";
+};
+const staticCopyWatchPaths = (mappings, cwd = process.cwd()) => {
+	if (mappings == null || mappings.length === 0) return [];
+	return [...new Set(mappings.map(({ from }) => {
+		assertRelative(from, "Copy source", cwd);
+		const base = resolve(cwd, staticBase(from));
+		if (!isInside$1(cwd, base)) throw new Error(`Copy source is outside the project root: ${from}`);
+		return base;
+	}))];
+};
+const assertRelative = (path, label, cwd = process.cwd()) => {
+	if (path.length === 0 || isAbsolute(path) || !isInside$1(cwd, resolve(cwd, path))) throw new Error(`${label} must be relative to the project root: ${path}`);
+};
+const assertNoSymlink = async (path, directory) => {
+	const target = dirname(path);
+	if (!isInside$1(directory, target)) throw new Error(`Copy destination is outside the build output directory: ${path}`);
+	let current = directory;
+	for (const segment of relative(directory, target).split("/").filter(Boolean)) {
+		current = resolve(current, segment);
+		try {
+			if ((await lstat(current)).isSymbolicLink()) throw new Error(`Refusing to copy through symbolic link: ${path}`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+};
+const assertSourceInsideProject = async (file, cwd) => {
+	if (!isInside$1(await realpath(cwd), await realpath(file))) throw new Error(`Copy source is outside the project root: ${file}`);
+};
+const planStaticCopies = async (mappings, outDir, cwd = process.cwd()) => {
+	if (mappings == null || mappings.length === 0) return [];
+	const output = resolve(cwd, outDir);
+	if (!isInside$1(cwd, output)) throw new Error(`Build output directory must be within the project root: ${outDir}`);
+	await assertNoSymlink(resolve(output, ".webanvil-static-copy"), cwd);
+	const files = (await Promise.all(mappings.map(async ({ from, to }) => {
+		assertRelative(from, "Copy source", cwd);
+		assertRelative(to, "Copy destination", cwd);
+		const base = resolve(cwd, staticBase(from));
+		if (!isInside$1(cwd, base)) throw new Error(`Copy source is outside the project root: ${from}`);
+		const files = await glob(from, {
+			cwd,
+			dot: true,
+			onlyFiles: true
+		});
+		return Promise.all(files.map(async (file) => {
+			const source = resolve(cwd, file);
+			await assertSourceInsideProject(source, cwd);
+			const destination = resolve(output, to, relative(base, source));
+			if (!isInside$1(output, destination) || !isInside$1(cwd, destination)) throw new Error(`Copy destination is outside the build output directory: ${to}`);
+			return {
+				from: source,
+				to: destination
+			};
+		}));
+	}))).flat();
+	const destinations = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		if (destinations.has(file.to)) throw new Error(`Duplicate copy destination: ${relative(output, file.to)}`);
+		destinations.add(file.to);
+	}
+	return files;
+};
+const copyStaticFiles = async (copies, generated, cwd = process.cwd()) => {
+	if (copies.length === 0) return [];
+	await assertStaticCopyDestinationsAvailable(copies, generated);
+	for (const { from, to } of copies) {
+		await assertNoSymlink(to, cwd);
+		await mkdir(dirname(to), { recursive: true });
+		await copyFile(from, to);
+	}
+	return copies.map(({ to }) => to);
+};
+const assertStaticCopyDestinationsAvailable = async (copies, generated = [], checkExisting = true) => {
+	const generatedPaths = new Set(generated.map((file) => resolve(process.cwd(), file)));
+	for (const { to } of copies) {
+		if (generatedPaths.has(to)) throw new Error(`Copy destination collides with generated output: ${to}`);
+		if (!checkExisting) continue;
+		try {
+			await lstat(to);
+			throw new Error(`Copy destination already exists: ${to}`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+};
+var StaleNodeWatchBuild = class extends Error {};
+const createNodeBuildPlan = async (entry, outDir, options, plugins, native = {}, toolchain = new Toolchain(process.cwd())) => {
+	const cwd = process.cwd();
+	const packageOptions = await resolvePackageOutputOptions(options, cwd);
+	const resolvedOptions = {
+		...options,
+		...packageOptions
+	};
+	const formats = resolvedOptions.formats ?? ["esm"];
+	const target = resolve(cwd, outDir);
+	const declaration = resolvedOptions.declaration;
+	const combinedDeclarations = declaration !== false && declaration !== void 0 && formats.length === 1 && formats[0] === "esm";
+	const declarationPlugins = declaration === false || declaration === void 0 ? [] : await createDeclarationPlugins(declaration, cwd, toolchain, !combinedDeclarations);
+	const output = nodeOutputPlan({
+		bundle: resolvedOptions.bundle,
+		cwd,
+		declarationPlugins: combinedDeclarations ? declarationPlugins : [],
+		entry,
+		entries: resolvedOptions.entries,
+		formats,
+		minify: resolvedOptions.minify,
+		native,
+		outDir: target,
+		platform: resolvedOptions.platform,
+		plugins,
+		sourcemap: resolvedOptions.sourcemap,
+		target: resolvedOptions.target
+	});
+	const declarationOutput = declarationPlugins.length === 0 || combinedDeclarations ? void 0 : nodeOutputPlan({
+		bundle: resolvedOptions.bundle,
+		cwd,
+		declarationPlugins,
+		entry,
+		entries: resolvedOptions.entries,
+		formats: ["esm"],
+		native,
+		outDir: target,
+		platform: resolvedOptions.platform,
+		plugins,
+		target: resolvedOptions.target
+	});
+	return {
+		cwd,
+		...declarationOutput === void 0 ? {} : { declarationOutput },
+		options: resolvedOptions,
+		outDir: target,
+		output
+	};
+};
+const bundleOutput = (bundle) => ({ output: Object.values(bundle) });
+const generatedPaths = (plan, files) => files.map(({ fileName }) => resolve(plan.outDir, fileName));
+const isInside = (directory, target) => {
+	const path = relative(directory, target);
+	return path === "" || path !== ".." && !path.startsWith("../") && !isAbsolute(path);
+};
+const displayPath = (path, cwd) => relative(cwd, path) || ".";
+const isDeclarationOutput = (path) => /\.d\.[cm]?ts$/.test(path);
+const canonicalPath = async (path) => {
+	try {
+		return await realpath(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return resolve(path);
+		throw error;
+	}
+};
+const assertNoSymlinkDestination = async (path, cwd) => {
+	let directory = dirname(path);
+	while (directory !== resolve(cwd)) {
+		if (!isInside(cwd, directory)) throw new Error(`Node output is outside the project root: ${path}`);
+		try {
+			if ((await lstat(directory)).isSymbolicLink()) throw new Error(`Refusing to write Node output through symbolic link: ${path}`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		directory = dirname(directory);
+	}
+};
+const preflightBuild = async (plan, files, copies, sources) => {
+	const info = await readBuildInfo(plan.cwd);
+	const tracked = new Set(info.output.map((file) => resolve(plan.cwd, file)));
+	const authoredInputs = new Set([...plan.output.authoredInputs, ...plan.declarationOutput?.authoredInputs ?? []].map((file) => resolve(file)));
+	const canonicalSources = /* @__PURE__ */ new Map();
+	for (const source of sources) canonicalSources.set(await canonicalPath(source), source);
+	const destinations = [...generatedPaths(plan, files).map((path) => ({
+		kind: "generated",
+		path
+	})), ...copies.map(({ to }) => ({
+		kind: "copied",
+		path: to
+	}))];
+	for (const destination of destinations) {
+		if (!isInside(plan.outDir, destination.path) || !isInside(plan.cwd, destination.path)) throw new Error(`Node output is outside the build output directory: ${destination.path}`);
+		const source = canonicalSources.get(await canonicalPath(destination.path));
+		await assertNoSymlinkDestination(destination.path, plan.cwd);
+		let exists = false;
+		try {
+			await lstat(destination.path);
+			exists = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		const generatedDeclarationAlias = destination.kind === "generated" && source !== void 0 && resolve(source) === resolve(destination.path) && isDeclarationOutput(destination.path) && !authoredInputs.has(resolve(source)) && (!exists || tracked.has(destination.path));
+		if (source !== void 0 && !generatedDeclarationAlias) throw new Error(`Node ${destination.kind} output ${displayPath(destination.path, plan.cwd)} aliases authored source ${displayPath(source, plan.cwd)}`);
+		if (exists && !tracked.has(destination.path)) throw new Error(`Node ${destination.kind} output already exists and is not tracked by WebAnvil: ${displayPath(destination.path, plan.cwd)}`);
+	}
+	return {
+		previous: info.output.filter((file) => isInside(plan.outDir, resolve(plan.cwd, file))),
+		retained: info.output.filter((file) => !isInside(plan.outDir, resolve(plan.cwd, file)))
+	};
+};
+const stageBuild = async (plan, files, copies) => {
+	await mkdir(resolve(plan.cwd, ".webanvil"), { recursive: true });
+	const directory = await mkdtemp(resolve(plan.cwd, ".webanvil", "node-output-"));
+	const next = resolve(directory, "next");
+	const generated = generatedPaths(plan, files);
+	try {
+		await assertStaticCopyDestinationsAvailable(copies, generated, false);
+		for (const file of files) {
+			const target = resolve(next, file.fileName);
+			if (!isInside(next, target)) throw new Error(`Node output is outside the build output directory: ${file.fileName}`);
+			await mkdir(dirname(target), { recursive: true });
+			await writeFile(target, file.source);
+		}
+		for (const copy of copies) {
+			const target = resolve(next, relative(plan.outDir, copy.to));
+			await mkdir(dirname(target), { recursive: true });
+			await copyFile(copy.from, target);
+		}
+		return {
+			directory,
+			next,
+			output: [...generated, ...copies.map(({ to }) => to)]
+		};
+	} catch (error) {
+		await rm(directory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
+	}
+};
+const restoreBuildInfo = async (cwd, contents) => {
+	const path = resolve(cwd, ".webanvil", "buildinfo.json");
+	await rm(`${path}.tmp`, { force: true });
+	if (contents === void 0) {
+		await rm(path, { force: true });
+		return;
+	}
+	const temporary = `${path}.rollback`;
+	await writeFile(temporary, contents);
+	await rename(temporary, path);
+};
+const readBuildInfoContents = async (cwd) => {
+	try {
+		return await readFile(resolve(cwd, ".webanvil", "buildinfo.json"), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+};
+const commitBuild = async (plan, files, copies, sources, fileSystem = { rename }, isCurrent = () => true) => {
+	const assertCurrent = () => {
+		if (!isCurrent()) throw new StaleNodeWatchBuild();
+	};
+	assertCurrent();
+	const { previous, retained } = await preflightBuild(plan, files, copies, sources);
+	assertCurrent();
+	const previousBuildInfo = await readBuildInfoContents(plan.cwd);
+	const staged = await stageBuild(plan, files, copies);
+	const moved = [];
+	const installed = [];
+	try {
+		assertCurrent();
+		for (const file of previous) {
+			assertCurrent();
+			const target = resolve(plan.cwd, file);
+			const backup = resolve(staged.directory, "previous", file);
+			await mkdir(dirname(backup), { recursive: true });
+			try {
+				await fileSystem.rename(target, backup);
+				moved.push({
+					backup,
+					target
+				});
+				assertCurrent();
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		}
+		for (const output of staged.output) {
+			assertCurrent();
+			const target = resolve(output);
+			const source = resolve(staged.next, relative(plan.outDir, target));
+			await mkdir(dirname(target), { recursive: true });
+			await fileSystem.rename(source, target);
+			installed.push(target);
+			assertCurrent();
+		}
+		assertCurrent();
+		await writeBuildInfo([...retained, ...staged.output], plan.cwd);
+		assertCurrent();
+		return staged.output;
+	} catch (error) {
+		const rollbackErrors = [];
+		for (const target of installed.reverse()) try {
+			await rm(target, { force: true });
+		} catch (rollbackError) {
+			rollbackErrors.push(rollbackError);
+		}
+		for (const previous of moved.reverse()) try {
+			await mkdir(dirname(previous.target), { recursive: true });
+			await fileSystem.rename(previous.backup, previous.target);
+		} catch (rollbackError) {
+			rollbackErrors.push(rollbackError);
+		}
+		try {
+			await restoreBuildInfo(plan.cwd, previousBuildInfo);
+		} catch (rollbackError) {
+			rollbackErrors.push(rollbackError);
+		}
+		if (rollbackErrors.length > 0) throw new AggregateError([error, ...rollbackErrors], "Node build commit failed and rollback was incomplete");
+		throw error;
+	} finally {
+		await rm(staged.directory, {
+			force: true,
+			recursive: true
+		});
+	}
+};
+const generateOutput = async (plan, rolldown) => {
+	const bundle = await rolldown(plan.input);
+	try {
+		return await Promise.all(plan.output.map((output) => bundle.generate(output)));
+	} finally {
+		await bundle.close();
+	}
+};
+const generatedBuild = (plan, outputs, declarationOutputs = []) => ({
+	files: generatedNodeFiles([...outputs, ...declarationOutputs]),
+	sources: [.../* @__PURE__ */ new Set([...authoredNodeSources(plan.output, outputs), ...plan.declarationOutput === void 0 ? [] : authoredNodeSources(plan.declarationOutput, declarationOutputs)])]
+});
+const runNodeBuild = async (plan, rolldown, fileSystem = { rename }) => {
+	const outputs = await generateOutput(plan.output, rolldown);
+	const declarationOutputs = plan.declarationOutput === void 0 ? [] : await generateOutput(plan.declarationOutput, rolldown);
+	const { files, sources } = generatedBuild(plan, outputs, declarationOutputs);
+	const copies = await planStaticCopies(plan.options.copy, plan.outDir, plan.cwd);
+	return commitBuild(plan, files, copies, sources, fileSystem);
+};
+const nodeWatchLifecycle = (plan, rolldown) => {
+	let generation = 0;
+	let outputs = [];
+	let copies = [];
+	let commits = Promise.resolve();
+	return {
+		abort: () => {
+			generation += 1;
+			outputs = [];
+			copies = [];
+		},
+		plugin: {
+			name: "webanvil-node-watch",
+			async buildStart() {
+				copies = await planStaticCopies(plan.options.copy, plan.outDir, plan.cwd);
+				for (const path of [...staticCopyWatchPaths(plan.options.copy, plan.cwd), ...copies.map(({ from }) => from)]) this.addWatchFile(path);
+			},
+			generateBundle(_options, bundle) {
+				outputs.push(bundleOutput(bundle));
+			}
+		},
+		complete: async () => {
+			const completedGeneration = generation;
+			const completedOutputs = outputs;
+			const completedCopies = copies;
+			if (plan.declarationOutput !== void 0 && rolldown === void 0) throw new Error("The declaration-only watch graph requires the selected Rolldown API");
+			const declarationOutputs = plan.declarationOutput === void 0 ? [] : await generateOutput(plan.declarationOutput, rolldown);
+			const build = generatedBuild(plan, completedOutputs, declarationOutputs);
+			const commit = async () => {
+				if (completedGeneration !== generation) return void 0;
+				try {
+					return await commitBuild(plan, build.files, completedCopies, build.sources, void 0, () => completedGeneration === generation);
+				} catch (error) {
+					if (error instanceof StaleNodeWatchBuild) return void 0;
+					throw error;
+				}
+			};
+			const pending = commits.then(commit, commit);
+			commits = pending.then(() => void 0, () => void 0);
+			return pending;
+		}
+	};
+};
+const logger = consola.withTag("webanvil");
+const announced = /* @__PURE__ */ new Set();
+const useTool = async (name, toolchain = new Toolchain(process.cwd())) => {
+	const tool = await toolchain.resolve(name);
+	const identity = `${tool.packageRoot}:${tool.version}`;
+	if (!announced.has(identity)) {
+		announced.add(identity);
+		logger.info(`Using ${formatResolvedTool(tool)}`);
+	}
+	return tool;
+};
+const useToolApi = async (name, subpath, toolchain = new Toolchain(process.cwd())) => (await useTool(name, toolchain)).import(subpath);
+const useToolExecutable = async (name, toolchain = new Toolchain(process.cwd())) => {
+	const tool = await useTool(name, toolchain);
+	if (tool.executable === void 0) throw new Error(`${tool.packageName} does not expose an executable`);
+	return tool.executable;
+};
+const bundle = defineOption({
+	name: "bundle",
+	description: "Bundle the Node public roots; without it, emit their reachable graph with preserveModules.",
+	arity: 0
+});
+const check = defineOption({
+	name: "check",
+	description: "Check formatting without writing files.",
+	arity: 0
+});
+const parseMapping = (value) => {
+	const separator = value.indexOf("=");
+	if (separator <= 0 || separator === value.length - 1) throw new Error(`Invalid copy mapping: ${value}. Expected source=destination.`);
+	return {
+		from: value.slice(0, separator),
+		to: value.slice(separator + 1)
+	};
+};
+const copy = defineOption({
+	name: "copy",
+	description: "Copy source=destination mappings after the build.",
+	schema: z.array(z.string()).transform((values) => values.map(parseMapping))
+});
+const coverage = defineOption({
+	name: "coverage",
+	description: "Collect test coverage with V8.",
+	arity: 0
+});
+const declaration = defineOption({
+	name: "declaration",
+	description: "Emit TypeScript declarations for a Node build.",
+	arity: 1,
+	schema: z.enum(["true", "false"]).transform((value) => value === "true")
+});
+const environment = defineOption({
+	name: "environment",
+	description: "Vitest environment to use for this run.",
+	arity: 1
+});
+const formats = defineOption({
+	name: "formats",
+	description: "Comma-separated Node output formats: esm,cjs.",
+	arity: 1,
+	schema: z.string().transform((value) => value.split(",")).pipe(z.array(z.enum(["esm", "cjs"])).min(1))
+});
+const fix$1 = defineOption({
+	name: "fix",
+	description: "Apply safe lint fixes.",
+	arity: 0
+});
+const host = defineOption({
+	name: "host",
+	description: "Host interface for the web server.",
+	arity: 1
+});
+const minify = defineOption({
+	name: "minify",
+	description: "Minify the build output: true or false.",
+	arity: 1,
+	schema: z.enum(["true", "false"]).transform((value) => value === "true")
+});
+const mode = defineOption({
+	name: "mode",
+	description: "Build mode: web uses Vite and node uses Rolldown.",
+	arity: 1,
+	schema: z.enum(["web", "node"])
+});
+const open = defineOption({
+	name: "open",
+	description: "Open the preview in the browser.",
+	arity: 0
+});
+const outDir = defineOption({
+	name: "out-dir",
+	description: "Directory where the build output is written.",
+	arity: 1
+});
+const platform = defineOption({
+	name: "platform",
+	description: "Node build platform: node, browser, or neutral.",
+	arity: 1,
+	schema: z.enum([
+		"node",
+		"browser",
+		"neutral"
+	])
+});
+const port = defineOption({
+	name: "port",
+	description: "Port for the web server.",
+	arity: 1,
+	schema: z.coerce.number().int().min(1).max(65535)
+});
+const sourcemap = defineOption({
+	name: "sourcemap",
+	description: "Generate source maps: true or false.",
+	arity: 1,
+	schema: z.enum(["true", "false"]).transform((value) => value === "true")
+});
+const target = defineOption({
+	name: "target",
+	description: "Production syntax target, or comma-separated targets.",
+	arity: 1,
+	schema: z.string().min(1).transform((value) => {
+		const values = value.split(",").map((part) => part.trim());
+		return values.length === 1 ? values[0] : values;
+	}).pipe(syntaxTargetSchema)
+});
+const ui = defineOption({
+	name: "ui",
+	description: "Start the Vitest user interface.",
+	arity: 0
+});
+const uiPort = defineOption({
+	name: "ui-port",
+	description: "Port for the Vitest user interface.",
+	arity: 1,
+	schema: z.coerce.number().int().min(1).max(65535)
+});
+const watch = defineOption({
+	name: "watch",
+	description: "Watch test files and rerun affected tests.",
+	arity: 0
+});
+const noBundle$1 = defineOption({
+	name: "no-bundle",
+	description: "Emit the reachable Node graph with preserveModules, overriding configuration that enables bundling.",
+	arity: 0
+});
+const outputFiles = (result, outDir) => {
+	if ("on" in result) throw new Error("Web builds cannot use watch mode");
+	return (Array.isArray(result) ? result : [result]).flatMap((output) => output.output.map((file) => resolve(outDir, file.fileName)));
+};
+const build = async (mode, entry, outDir, options = {}, plugins = [], viteConfig = {}, rolldownConfig = {}, toolchain = new Toolchain(process.cwd()), explicit = {}) => {
+	assertSyntaxTarget(options.target);
+	if (mode === "web" && options.platform !== void 0) throw new Error("Web builds do not accept platform; platform applies only to Node builds");
+	logger.start(`Building ${entry}`);
+	if (mode === "node") {
+		const rolldown = await useToolApi("rolldown", void 0, toolchain);
+		await runNodeBuild(await createNodeBuildPlan(entry, outDir, options, resolveRolldownPlugins(plugins), rolldownConfig, toolchain), rolldown.rolldown);
+		logger.success(`Built ${entry} to ${outDir}`);
+		return;
+	}
+	const web = await build.webConfig(entry, outDir, options, plugins, viteConfig, toolchain, explicit);
+	const target = web.outDir;
+	const copies = await planStaticCopies(options.copy, target);
+	if (web.emptyOutDir && copies.length > 0) throw new Error("Vite build.emptyOutDir must be false when using static copy mappings");
+	await assertStaticCopyDestinationsAvailable(copies, await build.publicOutputFiles(web), false);
+	const existing = await removeOutputsIn(target);
+	await assertStaticCopyDestinationsAvailable(copies);
+	const output = await build.web(web);
+	const copied = await copyStaticFiles(copies, output);
+	await writeBuildInfo([
+		...existing.output,
+		...output,
+		...copied
+	]);
+	logger.success(`Built ${entry} to ${outDir}`);
+};
+build.webConfig = async (entry, outDir, options, plugins, viteConfig = {}, toolchain = new Toolchain(process.cwd()), explicit = {}) => {
+	assertSyntaxTarget(options.target);
+	if (options.platform !== void 0) throw new Error("Web builds do not accept platform; platform applies only to Node builds");
+	if (options.formats?.some((format) => format !== "esm")) throw new Error("Web builds only support the esm format");
+	const preserveOutput = options.copy != null && options.copy.length > 0;
+	const vite = await useToolApi("vite", void 0, toolchain);
+	const webanvilDefaults = {
+		root: process.cwd(),
+		plugins: resolveVitePlugins(plugins),
+		build: {
+			...preserveOutput ? { emptyOutDir: false } : {},
+			outDir: resolve(process.cwd(), outDir),
+			minify: options.minify,
+			sourcemap: options.sourcemap,
+			...options.target === void 0 ? {} : { target: options.target },
+			rolldownOptions: { input: resolve(process.cwd(), entry) }
+		}
+	};
+	const explicitBuild = {
+		...explicit.outDir === void 0 ? {} : { outDir: resolve(process.cwd(), explicit.outDir) },
+		...explicit.minify === void 0 ? {} : { minify: explicit.minify },
+		...explicit.sourcemap === void 0 ? {} : { sourcemap: explicit.sourcemap },
+		...explicit.target === void 0 ? {} : { target: explicit.target },
+		...explicit.entry === void 0 ? {} : { rolldownOptions: { input: resolve(process.cwd(), explicit.entry) } },
+		...preserveOutput ? { emptyOutDir: false } : {}
+	};
+	const config = await hasToolConfig("vite") ? {
+		root: process.cwd(),
+		...Object.keys(explicitBuild).length === 0 ? {} : { build: explicitBuild }
+	} : vite.mergeConfig(vite.mergeConfig(webanvilDefaults, viteConfig), Object.keys(explicitBuild).length === 0 ? {} : { build: explicitBuild });
+	const resolved = await vite.resolveConfig(config, "build", "production", "production");
+	return {
+		config,
+		emptyOutDir: resolved.build.emptyOutDir === true,
+		outDir: resolved.build.outDir,
+		publicDir: resolved.build.copyPublicDir ? resolved.publicDir : void 0,
+		vite
+	};
+};
+build.publicOutputFiles = async ({ outDir, publicDir }) => publicDir ? (await glob("**/*", {
+	cwd: publicDir,
+	onlyFiles: true,
+	dot: true
+})).map((file) => resolve(outDir, file)) : [];
+build.web = async (web) => [...outputFiles(await web.vite.build(web.config), web.outDir), ...await build.publicOutputFiles(web)];
+const commandRun$1 = (toolchain) => withConfig((config) => config.build, ({ copy, declaration, formats, minify, mode, entry, "out-dir": outDir, platform, sourcemap, target }, buildConfig, resolvedConfig, explicit) => {
+	if (explicit.bundle && explicit["no-bundle"]) throw new Error("--bundle and --no-bundle cannot be used together");
+	const effective = resolveEffectiveBuildConfig(resolvedConfig, {
+		bundle: explicit["no-bundle"] ? false : explicit.bundle ? true : buildConfig.bundle,
+		copy,
+		declaration,
+		entries: buildConfig.entries,
+		entry,
+		formats,
+		minify,
+		mode,
+		outDir,
+		platform,
+		sourcemap,
+		target
+	}, explicit.entry !== void 0);
+	return build(effective.mode, effective.entry, effective.outDir, effective, resolvedConfig.plugins ?? [], resolvedConfig.vite, resolvedConfig.rolldown, toolchain, {
+		...explicit.entry === void 0 ? {} : { entry },
+		...explicit["out-dir"] === void 0 ? {} : { outDir },
+		...explicit.minify === void 0 ? {} : { minify },
+		...explicit.sourcemap === void 0 ? {} : { sourcemap },
+		...explicit.target === void 0 ? {} : { target }
+	});
+});
+var build_default = defineCommand({
+	name: "build",
+	arguments: [entry],
+	options: [
+		mode,
+		outDir,
+		bundle,
+		noBundle$1,
+		copy,
+		declaration,
+		sourcemap,
+		minify,
+		formats,
+		platform,
+		target
+	],
+	run: async (arguments_) => {
+		const toolchain = new Toolchain(process.cwd());
+		await Promise.all([toolchain.resolve("vite"), toolchain.resolve("rolldown")]);
+		return commandRun$1(toolchain)(arguments_);
+	}
+});
+const rebasePath = (path, cwd, configDirectory) => {
+	if (isAbsolute(path)) return path;
+	const rebased = relative(configDirectory, resolve(cwd, path));
+	return rebased.startsWith(".") ? rebased : `./${rebased}`;
+};
+const rebaseTailwind = (value, cwd, configDirectory) => {
+	if (typeof value !== "object" || value === null || value instanceof Array) return value;
+	const tailwind = { ...value };
+	for (const key of ["config", "stylesheet"]) if (typeof tailwind[key] === "string") tailwind[key] = rebasePath(tailwind[key], cwd, configDirectory);
+	return tailwind;
+};
+const rebaseOxfmtConfig = (config, cwd, configDirectory) => ({
+	...config,
+	...config.sortTailwindcss === void 0 ? {} : { sortTailwindcss: rebaseTailwind(config.sortTailwindcss, cwd, configDirectory) },
+	...config.overrides instanceof Array ? { overrides: config.overrides.map((override) => {
+		if (typeof override !== "object" || override === null || override instanceof Array) return override;
+		const value = override;
+		const overrideOptions = typeof value.options === "object" && value.options !== null && !(value.options instanceof Array) ? value.options : void 0;
+		const options = overrideOptions === void 0 ? value.options : {
+			...overrideOptions,
+			...overrideOptions.sortTailwindcss === void 0 ? {} : { sortTailwindcss: rebaseTailwind(overrideOptions.sortTailwindcss, cwd, configDirectory) }
+		};
+		return {
+			...value,
+			...options === void 0 ? {} : { options }
+		};
+	}) } : {}
+});
+const rebasePlugin = (plugin, cwd, configDirectory) => {
+	if (typeof plugin === "string") return plugin.startsWith(".") ? rebasePath(plugin, cwd, configDirectory) : plugin;
+	if (typeof plugin !== "object" || plugin === null || plugin instanceof Array) return plugin;
+	const value = plugin;
+	return typeof value.specifier === "string" && value.specifier.startsWith(".") ? {
+		...value,
+		specifier: rebasePath(value.specifier, cwd, configDirectory)
+	} : value;
+};
+const rebaseOxlintConfig = (config, cwd, configDirectory) => ({
+	...config,
+	...config.extends instanceof Array ? { extends: config.extends.map((path) => typeof path === "string" ? rebasePath(path, cwd, configDirectory) : path) } : {},
+	...config.jsPlugins instanceof Array ? { jsPlugins: config.jsPlugins.map((plugin) => rebasePlugin(plugin, cwd, configDirectory)) } : {},
+	...config.overrides instanceof Array ? { overrides: config.overrides.map((override) => {
+		if (typeof override !== "object" || override === null || override instanceof Array) return override;
+		const value = override;
+		return {
+			...value,
+			...value.jsPlugins instanceof Array ? { jsPlugins: value.jsPlugins.map((plugin) => rebasePlugin(plugin, cwd, configDirectory)) } : {}
+		};
+	}) } : {}
+});
+const runTool = async (name, arguments_, config) => {
+	if (name !== "tsgo" && await hasOxcConfig(name)) config = void 0;
+	const executable = await useToolExecutable(name === "tsgo" ? "typescript-native" : name);
+	const cwd = process.cwd();
+	const configDirectory = join(cwd, ".webanvil");
+	const configPath = config === void 0 ? void 0 : join(configDirectory, `${name}-${randomUUID()}.json`);
+	const sourceConfig = config;
+	const ignorePatterns = sourceConfig?.ignorePatterns instanceof Array ? sourceConfig.ignorePatterns.filter((pattern) => typeof pattern === "string") : [];
+	const configWithoutIgnores = sourceConfig === void 0 ? void 0 : Object.fromEntries(Object.entries(sourceConfig).filter(([key]) => key !== "ignorePatterns"));
+	const generatedConfig = configWithoutIgnores === void 0 || configPath === void 0 ? configWithoutIgnores : name === "oxfmt" ? rebaseOxfmtConfig(configWithoutIgnores, cwd, configDirectory) : rebaseOxlintConfig(configWithoutIgnores, cwd, configDirectory);
+	const ignoreArguments = name === "oxfmt" ? ignorePatterns.map((pattern) => pattern.startsWith("!") ? pattern.slice(1) : `!${pattern}`) : ignorePatterns.flatMap((pattern) => ["--ignore-pattern", pattern]);
+	const internalIgnoreArguments = name === "oxfmt" ? ["!**/.webanvil/**"] : ["--ignore-pattern", ".webanvil/**"];
+	const toolArguments = name === "tsgo" ? arguments_ : [
+		...configPath === void 0 ? [] : ["--config", configPath],
+		...ignoreArguments,
+		...internalIgnoreArguments,
+		...name === "oxfmt" && arguments_.length === 0 ? ["."] : arguments_
+	];
+	if (configPath !== void 0) {
+		await mkdir(configDirectory, { recursive: true });
+		await writeFile(configPath, `${JSON.stringify(generatedConfig)}\n`);
+	}
+	try {
+		const result = await execa(executable, toolArguments, {
+			reject: false,
+			stdio: "inherit"
+		});
+		if (result.exitCode !== 0) throw new Error(`${name} exited with code ${result.exitCode ?? "unknown"}`);
+	} finally {
+		if (configPath !== void 0) await rm(configPath, { force: true });
+	}
+};
+const format = async (paths, check = false, config) => {
+	logger.start(check ? "Checking formatting" : "Formatting");
+	await runTool("oxfmt", [...check ? ["--check"] : [], ...paths], config);
+	logger.success(check ? "Formatting passed" : "Formatted");
+};
+const runFormat = withConfig((config) => config.format, ({ paths, check }, config) => format(paths, check, config));
+var format_default = defineCommand({
+	name: "format",
+	arguments: [paths],
+	options: [check],
+	run: async (arguments_) => {
+		await useTool("oxfmt");
+		return runFormat(arguments_);
+	}
+});
+const lint = async (paths, fix = false, config) => {
+	logger.start("Linting");
+	await runTool("oxlint", [
+		...fix ? ["--fix"] : [],
+		"--deny-warnings",
+		...paths
+	], config);
+	logger.success("Lint passed");
+};
+const runLint = withConfig((config) => config.lint, ({ paths, fix }, config) => lint(paths, fix, config));
+var lint_default = defineCommand({
+	name: "lint",
+	arguments: [paths],
+	options: [fix$1],
+	run: async (arguments_) => {
+		await useTool("oxlint");
+		return runLint(arguments_);
+	}
+});
+const typecheckArguments = async (paths) => {
+	if (paths.length > 0) return [
+		"--noEmit",
+		"--ignoreConfig",
+		...paths
+	];
+	return getTsconfig(process.cwd(), { typescriptVersion: false })?.config.references?.length ? ["-b", "--noEmit"] : ["--noEmit"];
+};
+const typecheck = async (paths) => {
+	logger.start("Type checking");
+	await runTool("tsgo", await typecheckArguments(paths));
+	logger.success("Type check passed");
+};
+var typecheck_default = defineCommand({
+	name: "typecheck",
+	arguments: [paths],
+	run: ({ paths }) => typecheck(paths)
+});
+const fix = defineOption({
+	name: "fix",
+	description: "Format files and apply safe lint fixes.",
+	arity: 0
+});
+const checkProject = async (fixFiles = false, config = {}) => {
+	await format([], !fixFiles, config.format);
+	await lint([], fixFiles, config.lint);
+	await typecheck([]);
+};
+var check_default = defineCommand({
+	name: "check",
+	description: "Check formatting, linting, and types, stopping at the first failure.",
+	options: [fix],
+	run: async ({ fix }) => {
+		await Promise.all([
+			useTool("oxfmt"),
+			useTool("oxlint"),
+			useTool("typescript-native")
+		]);
+		const { config } = await loadConfig$1();
+		await checkProject(fix, config);
+	}
+});
+const clean = async () => {
+	const info = await readBuildInfo();
+	await removeBuildOutputs(info.output);
+	await clearBuildInfo();
+	logger.success(`Removed ${info.output.length} build output${info.output.length === 1 ? "" : "s"}`);
+};
+var clean_default = defineCommand({
+	name: "clean",
+	run: clean
+});
+const untilTerminated = () => new Promise((resolve) => {
+	const terminate = () => {
+		process.off("SIGINT", terminate);
+		process.off("SIGTERM", terminate);
+		resolve();
+	};
+	process.once("SIGINT", terminate);
+	process.once("SIGTERM", terminate);
+});
+const noBundle = defineOption({
+	name: "no-bundle",
+	description: "Emit the reachable Node graph with preserveModules, overriding configuration that enables bundling.",
+	arity: 0
+});
+const dev = async (mode, entry, outDir, host, port, plugins = [], options = {}, viteConfig = {}, rolldownConfig = {}, toolchain = new Toolchain(process.cwd())) => {
+	assertSyntaxTarget(options.target);
+	if (mode === "web" && options.platform !== void 0) throw new Error("Web development does not accept platform; platform applies only to Node builds");
+	logger.start(`Starting ${mode} development mode`);
+	if (mode === "node" && (host !== void 0 || port !== void 0)) throw new Error("--host and --port are only available in web development mode");
+	if (mode === "web") await dev.web(host, port, plugins, untilTerminated, viteConfig, toolchain);
+	else await dev.node(entry, outDir, plugins, untilTerminated, options, rolldownConfig, toolchain);
+};
+dev.web = async (host, port, plugins = [], waitForTermination = untilTerminated, viteConfig = {}, toolchain = new Toolchain(process.cwd())) => {
+	const vite = await useToolApi("vite", void 0, toolchain);
+	const webanvilDefaults = {
+		root: process.cwd(),
+		plugins: resolveVitePlugins(plugins)
+	};
+	const explicit = {
+		root: process.cwd(),
+		...host === void 0 && port === void 0 ? {} : { server: {
+			host,
+			port
+		} }
+	};
+	const config = await hasToolConfig("vite") ? explicit : vite.mergeConfig(vite.mergeConfig(webanvilDefaults, viteConfig), explicit);
+	const server = await vite.createServer(config);
+	try {
+		await server.listen();
+		server.printUrls();
+		await waitForTermination();
+	} finally {
+		await server.close();
+	}
+};
+dev.node = async (entry, outDir, plugins = [], waitForTermination = untilTerminated, options = {}, rolldownConfig = {}, toolchain = new Toolchain(process.cwd())) => {
+	assertSyntaxTarget(options.target);
+	const rolldown = await useToolApi("rolldown", void 0, toolchain);
+	const plan = await createNodeBuildPlan(entry, outDir, options, resolveRolldownPlugins(plugins), rolldownConfig, toolchain);
+	const lifecycle = nodeWatchLifecycle(plan, rolldown.rolldown);
+	const watcher = rolldown.watch({
+		...plan.output.input,
+		plugins: [...plan.output.input.plugins ?? [], lifecycle.plugin],
+		watch: {
+			...typeof plan.output.input.watch === "object" ? plan.output.input.watch : {},
+			skipWrite: true
+		},
+		output: plan.output.output
+	});
+	let failed = false;
+	watcher.on("event", async (event) => {
+		if (event.code === "START") {
+			failed = false;
+			lifecycle.abort();
+		}
+		if (event.code === "BUNDLE_END") await event.result.close();
+		if (event.code === "END" && !failed) try {
+			if (await lifecycle.complete() !== void 0) logger.success(`Built ${entry} to ${outDir}`);
+		} catch (error) {
+			logger.error(error);
+		}
+		if (event.code === "ERROR") {
+			failed = true;
+			lifecycle.abort();
+			await event.result.close();
+			logger.error(event.error);
+		}
+	});
+	try {
+		await waitForTermination();
+	} finally {
+		lifecycle.abort();
+		await watcher.close();
+	}
+};
+const commandRun = (toolchain) => withConfig((config) => config.build, ({ copy, declaration, formats, minify, mode, entry, "out-dir": outDir, host, platform, port, sourcemap, target }, buildConfig, resolvedConfig, explicit) => {
+	if (explicit.bundle && explicit["no-bundle"]) throw new Error("--bundle and --no-bundle cannot be used together");
+	const effective = resolveEffectiveBuildConfig(resolvedConfig, {
+		bundle: explicit["no-bundle"] ? false : explicit.bundle ? true : buildConfig.bundle,
+		copy,
+		declaration,
+		entries: buildConfig.entries,
+		entry,
+		formats,
+		minify,
+		mode,
+		outDir,
+		platform,
+		sourcemap,
+		target
+	}, explicit.entry !== void 0);
+	return dev(effective.mode, effective.entry, effective.outDir, host, port, resolvedConfig.plugins ?? [], effective, resolvedConfig.vite, resolvedConfig.rolldown, toolchain);
+});
+var dev_default = defineCommand({
+	name: "dev",
+	arguments: [entry],
+	options: [
+		mode,
+		outDir,
+		host,
+		port,
+		bundle,
+		noBundle,
+		copy,
+		declaration,
+		sourcemap,
+		minify,
+		formats,
+		platform,
+		target
+	],
+	run: async (arguments_) => {
+		const toolchain = new Toolchain(process.cwd());
+		await Promise.all([toolchain.resolve("vite"), toolchain.resolve("rolldown")]);
+		return commandRun(toolchain)(arguments_);
+	}
+});
+const preview = async (outDir, host, port, useOutDir = false, waitForTermination = untilTerminated, openBrowser, viteConfig = {}) => {
+	logger.start("Starting web preview");
+	const vite = await useToolApi("vite");
+	const hasViteConfig = await hasToolConfig("vite");
+	const defaults = {
+		root: process.cwd(),
+		...hasViteConfig ? {} : { build: { outDir: resolve(process.cwd(), outDir) } }
+	};
+	const native = hasViteConfig ? defaults : vite.mergeConfig(defaults, viteConfig);
+	const config = vite.mergeConfig(native, {
+		...useOutDir ? { build: { outDir: resolve(process.cwd(), outDir) } } : {},
+		preview: {
+			...host === void 0 ? {} : { host },
+			...port === void 0 ? {} : { port },
+			...openBrowser === void 0 ? {} : { open: openBrowser }
+		}
+	});
+	const server = await vite.preview(config);
+	try {
+		server.printUrls();
+		await waitForTermination();
+	} finally {
+		await server.close();
+	}
+};
+var preview_default = defineCommand({
+	name: "preview",
+	options: [
+		outDir,
+		host,
+		port,
+		open
+	],
+	run: async ({ "out-dir": outDir, host, port, open }) => {
+		await useTool("vite");
+		const { config } = await loadConfig$1();
+		return preview(outDir ?? config.build?.outDir ?? "dist", host, port, outDir !== void 0, untilTerminated, open, config.vite);
+	}
+});
+const test = async (filters, config = {}, options = {}, waitForTermination = untilTerminated) => {
+	if (options.uiPort !== void 0 && options.ui !== true) throw new Error("--ui-port requires --ui");
+	logger.start("Running tests");
+	const hasVitestConfig = await hasToolConfig("vitest");
+	const persistent = options.watch === true || options.ui === true;
+	const { startVitest } = await useToolApi("vitest", "node");
+	const nativeConfig = hasVitestConfig ? {} : config;
+	const nativeCoverage = typeof nativeConfig.coverage === "object" && nativeConfig.coverage !== null ? nativeConfig.coverage : {};
+	const nativeApi = typeof nativeConfig.api === "object" && nativeConfig.api !== null ? nativeConfig.api : {};
+	const vitest = await startVitest("test", filters, {
+		...nativeConfig,
+		passWithNoTests: true,
+		run: !persistent,
+		watch: persistent,
+		...options.environment === void 0 ? {} : { environment: options.environment },
+		...options.coverage ? { coverage: {
+			...nativeCoverage,
+			enabled: true,
+			provider: "v8"
+		} } : {},
+		...options.ui ? { ui: true } : {},
+		...options.uiPort === void 0 ? {} : { api: {
+			...nativeApi,
+			host: "127.0.0.1",
+			port: options.uiPort,
+			strictPort: true
+		} }
+	});
+	if (persistent) {
+		try {
+			await waitForTermination();
+		} finally {
+			await vitest.close();
+		}
+		return;
+	}
+	const failed = vitest.state.getFiles().some((file) => file.result?.state === "fail") || vitest.state.getUnhandledErrors().length > 0;
+	await vitest.close();
+	if (failed) throw new Error("Tests failed");
+	logger.success("Tests passed");
+};
+const runTest = withConfig((config) => config.test, ({ filters, environment, coverage, ui, "ui-port": uiPort, watch }, config, _resolvedConfig, explicitArguments) => test(filters, config, {
+	coverage,
+	environment: explicitArguments.environment === void 0 ? void 0 : environment,
+	ui,
+	uiPort,
+	watch
+}));
+var test_default = defineCommand({
+	name: "test",
+	arguments: [filters],
+	options: [
+		environment,
+		watch,
+		coverage,
+		ui,
+		uiPort
+	],
+	run: async (arguments_) => {
+		await useTool("vitest");
+		return runTest(arguments_);
+	}
+});
+export { assertSyntaxTarget, build, buildConfigSchema, build_default, bundle, check, checkProject, check_default, clean, clean_default, copy, copyMappingSchema, coverage, declaration, defaultConfig, defineConfig, definePlugin, dev, dev_default, effectiveUserConfigSchema, entry, environment, filters, fix$1 as fix, format, formatConfigSchema, format_default, formats, host, isUnpluginAdapter, isWebAnvilPlugin, lint, lintConfigSchema, lint_default, loadConfig$1 as loadConfig, logger, minify, mode, open, outDir, paths, platform, port, preview, preview_default, resolveEffectiveBuildConfig, resolveRolldownPlugins, resolveVitePlugins, rolldownConfigSchema, sourcemap, syntaxTargetSchema, target, test, testConfigSchema, test_default, typecheck, typecheck_default, ui, uiPort, userConfigSchema, viteConfigSchema, watch, withConfig };