@crustjs/crust-darwin-x64 0.4.1 → 0.5.1

package/bin/dist/index.js

@@ -1,169 +1,34 @@
-import { accessSync, constants, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { chmod, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { accessSync, constants, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { chmod, copyFile, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
-import { pathToFileURL } from "node:url";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { once } from "node:events";
 import { text } from "node:stream/consumers";
-//#region ../utils/dist/artifacts.js
-/**
-* Set by `crust build` while it prepares the Command Snapshot: the absolute
-* entry-isolated directory Extension build hooks write into. Core reads it
-* to run the hooks; `resolveArtifactDir` reads it so sections evaluated during
-* that run see the artifacts being built instead of the wiped `.crust/root`.
-*/
-const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
-//#endregion
-//#region ../core/dist/invocation-ka-BNJKZ.js
-/**
-* A typed error for runtime recipe, Extension, Context, documentation, argv, and validation failures.
-*
-* Every `CrustError` carries a {@link CrustErrorCode} that identifies the specific
-* failure, enabling programmatic error handling without fragile message parsing.
-*
-* @example
-* ```ts
-* import { CrustError } from "@crustjs/core";
-*
-* const outcome = await app.run(["deploy"], { args: { target: "prod" } });
-* if (outcome.status === "failed") {
-*   const err = outcome.error;
-*   if (err instanceof CrustError) {
-*     console.error(`[${err.code}] ${err.message}`);
-*   }
-* }
-* ```
-*/
-var CrustError = class extends Error {
-	/** Machine-readable error code for programmatic handling */
-	code;
-	/** Structured payload for programmatic handling */
-	details;
-	/** Optional wrapped original error/value */
-	cause;
-	constructor(code, message, ...details) {
-		super(message);
-		this.name = "CrustError";
-		this.code = code;
-		this.details = details[0];
-	}
-	is(code) {
-		return Object.is(this.code, code);
-	}
-	withCause(cause) {
-		this.cause = cause;
-		return this;
-	}
-	toJSON() {
-		return {
-			code: this.code,
-			message: this.message,
-			details: this.details
-		};
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp$1(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
+	return to;
 };
-globalThis.AsyncDisposableStack;
-Object.freeze({ [Symbol("crust.finished")]: true });
-function invalidSections({ subject, name }) {
-	return new CrustError("DEFINITION", `${subject === "command" ? "Command" : "Extension"} "${name}" contains invalid documentation sections`, {
-		subject,
-		name,
-		reason: "invalid-sections"
-	});
-}
-function normalizeSection(section, owner) {
-	const { title, body, only, except } = section;
-	if (!title.trim() || /[\r\n]/.test(title) || !body.trim() || only?.length === 0 || except?.length === 0 || only !== void 0 && except !== void 0) throw invalidSections(owner);
-	const audience = (ids) => {
-		return Object.freeze(ids.map((consumer) => typeof consumer === "string" ? consumer : consumer.id));
-	};
-	return Object.freeze({
-		title,
-		body,
-		...only ? { only: audience(only) } : except ? { except: audience(except) } : {}
-	});
-}
-function validateCommandSections(name, sections) {
-	return sections.map((section) => normalizeSection(section, {
-		subject: "command",
-		name
-	}));
-}
-/**
-* Snapshot subprocess protocol used by first-party build tooling.
-*
-* When set to a non-empty file path, `.execute()` prepares the command tree,
-* validates its documentation sections, optionally runs Extension build hooks when the
-* build output directory is set, writes its final JSON snapshot and Build Report, and exits
-* without dispatching a Command Action. In-process callers use `Crust.snapshot()`.
-*
-* Only source entries run by `crust build` honor it: finished Bun/Node bundles carry
-* `process.env.CRUST_INTERNAL_BUILD === "1"` as a literal and compile the protocol out.
-*/
-const SNAPSHOT_PATH_ENV = "CRUST_INTERNAL_SNAPSHOT_PATH";
-//#endregion
-//#region ../core/dist/index.js
-/** Mint an Extension identity from any non-blank, trimmed string. */
-function defineExtensionId(id) {
-	if (!id.trim() || id !== id.trim()) throw new CrustError("DEFINITION", "Extension id must be a non-empty, trimmed string", {
-		subject: "extension",
-		reason: "empty-id"
-	});
-	return id;
-}
-const commandDefinitionInternal = Symbol.for("crust.commandDefinition");
-function resolveCommandName(name, aliases = []) {
-	if (name.trim() === "") throw new CrustError("DEFINITION", "Command name must be a non-empty string", {
-		subject: "command",
-		name,
-		reason: "empty-name"
-	});
-	if (name === "__proto__") throw new CrustError("DEFINITION", "Command name \"__proto__\" is reserved", {
-		subject: "command",
-		name,
-		reason: "reserved-name"
-	});
-	if (aliases.includes(name)) throw new CrustError("DEFINITION", `Command "${name}" must not list its own canonical name as an alias`, {
-		subject: "command",
-		name,
-		reason: "alias-collision"
-	});
-	return name;
-}
-function isCommandRecipe(value) {
-	return typeof value === "function";
-}
-function defineCommand(nameInput, configOrRecipe, maybeRecipe) {
-	const hasConfig = !isCommandRecipe(configOrRecipe);
-	const config = hasConfig ? configOrRecipe : {};
-	const recipe = hasConfig ? maybeRecipe : configOrRecipe;
-	const name = resolveCommandName(nameInput, config.aliases);
-	for (const alias of config.aliases ?? []) if (alias === "" || /[ \t\n\r\v\f]/.test(alias) || alias.startsWith("-")) throw new CrustError("DEFINITION", `Command "${name}" has an invalid alias "${alias}"`);
-	const { sections, version: _rootVersion, ...metaRest } = config;
-	const meta = {
-		...metaRest,
-		...config.aliases ? { aliases: [...config.aliases] } : {},
-		...sections ? { sections: validateCommandSections(name, sections) } : {}
-	};
-	const internal = {
-		name,
-		recipe,
-		meta
-	};
-	const named = (defName) => {
-		return Object.freeze({
-			name: defName,
-			as: (newName) => named(resolveCommandName(newName, meta.aliases)),
-			[commandDefinitionInternal]: Object.freeze({
-				...internal,
-				name: defName
-			})
-		});
-	};
-	return named(name);
-}
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp$1(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 //#endregion
 //#region ../style/dist/index.js
 var __defProp = Object.defineProperty;
@@ -1463,15 +1328,7 @@ function linkCode(url, options) {
 function link$1(text, url, options) {
 	return applyStyle(text, linkCode(url, options));
 }
-const dynamicColorKinds = [[
-	"fg",
-	fgPairAtDepth,
-	fg$1
-], [
-	"bg",
-	bgPairAtDepth,
-	bg$1
-]];
+const dynamicColorKinds = [["fg", fg$1], ["bg", bg$1]];
 const styleMethodPairs = ansiCodes_exports;
 function stepIsModifier(step) {
 	return step.kind === "named" && isModifierName(step.name);
@@ -1480,6 +1337,21 @@ function stepPair(step, colorDepth) {
 	if (step.kind === "named") return styleMethodPairs[step.name];
 	return step.kind === "fg" ? fgPairAtDepth(step.input, colorDepth) : bgPairAtDepth(step.input, colorDepth);
 }
+function colorStep(kind, input) {
+	const step = {
+		kind,
+		input
+	};
+	stepPair(step, "truecolor");
+	return Array.isArray(input) ? {
+		kind,
+		input: [
+			input[0],
+			input[1],
+			input[2]
+		]
+	} : step;
+}
 function applyChain(text, steps, resolveCapabilities) {
 	if (text == null) return "";
 	let result = String(text);
@@ -1527,16 +1399,10 @@ function buildChainableStyleFactory(resolveCapabilities, runtime) {
 				}]);
 			}
 		});
-		for (const [kind, pairAtDepth] of dynamicColorKinds) Object.defineProperty(styleFn, kind, {
+		for (const [kind] of dynamicColorKinds) Object.defineProperty(styleFn, kind, {
 			configurable: false,
 			enumerable: true,
-			value: (input) => {
-				pairAtDepth(input, "truecolor");
-				return createChainableStyle([...steps, {
-					kind,
-					input
-				}]);
-			},
+			value: (input) => createChainableStyle([...steps, colorStep(kind, input)]),
 			writable: false
 		});
 		let open = "";
@@ -1642,15 +1508,9 @@ function createStyleInstance(options, runtime) {
 			linkCode(url, hyperlinkOptions);
 			return text;
 		},
-		...Object.fromEntries(dynamicColorKinds.map(([kind, pairAtDepth, paint]) => [kind, (...args) => {
+		...Object.fromEntries(dynamicColorKinds.map(([kind, paint]) => [kind, (...args) => {
 			const resolved = resolveCapabilities();
-			if (args.length === 1) {
-				pairAtDepth(args[0], "truecolor");
-				return createChainableStyle([{
-					kind,
-					input: args[0]
-				}]);
-			}
+			if (args.length === 1) return createChainableStyle([colorStep(kind, args[0])]);
 			return paint(args[0], args[1], resolved.colorDepth);
 		}])),
 		...methods
@@ -1717,6 +1577,12 @@ style.link;
 style.fg;
 style.bg;
 //#endregion
+//#region ../utils/dist/error.js
+/** Narrows a caught Node.js system error to its stable errno contract. */
+function isErrnoException(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string";
+}
+//#endregion
 //#region ../utils/dist/json.js
 /** Narrow a JSON document root to an object (not array/scalar/null). */
 function isJsonObject(value) {
@@ -1730,10 +1596,96 @@ function isWithin(parent, child) {
 	return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
 //#endregion
-//#region ../utils/dist/error.js
-/** Narrows a caught Node.js system error to its stable errno contract. */
-function isErrnoException(error) {
-	return error instanceof Error && "code" in error && typeof error.code === "string";
+//#region ../utils/dist/artifacts.js
+/**
+* Set by `crust build` while it prepares the Command Snapshot: the absolute
+* entry-isolated directory Extension build hooks write into. Core reads it
+* to run the hooks; `resolveArtifactDir` reads it so sections evaluated during
+* that run see the artifacts being built instead of the wiped `.crust/root`.
+*/
+const BUILD_OUT_DIR_ENV = "CRUST_INTERNAL_BUILD_OUT_DIR";
+/**
+* `Symbol.for` registry key of the packaged-build marker, for bundlers without a
+* `define` option (native `deno bundle`). `crust build` prepends
+* `globalThis[Symbol.for(PACKAGED_BUILD_KEY)] = true` to the command bundle,
+* before the inlined application graph, so every bundled copy sees it.
+* The registry key is shared across module copies; the value is never read from
+* the environment, so detection needs no Deno env permission.
+*/
+const PACKAGED_BUILD_KEY = "crustjs.packagedBuild";
+//#endregion
+//#region ../core/dist/invocation-CD299Gic.js
+/**
+* A typed error for runtime recipe, Extension, Context, documentation, argv, and validation failures.
+*
+* Every `CrustError` carries a {@link CrustErrorCode} that identifies the specific
+* failure, enabling programmatic error handling without fragile message parsing.
+*
+* @example
+* ```ts
+* import { CrustError } from "@crustjs/core";
+*
+* const outcome = await app.run(["deploy"], { args: { target: "prod" } });
+* if (outcome.status === "failed") {
+*   const err = outcome.error;
+*   if (err instanceof CrustError) {
+*     console.error(`[${err.code}] ${err.message}`);
+*   }
+* }
+* ```
+*/
+var CrustError = class extends Error {
+	/** Machine-readable error code for programmatic handling */
+	code;
+	/** Structured payload for programmatic handling */
+	details;
+	/** Optional wrapped original error/value */
+	cause;
+	constructor(code, message, ...details) {
+		super(message);
+		this.name = "CrustError";
+		this.code = code;
+		this.details = details[0];
+	}
+	is(code) {
+		return Object.is(this.code, code);
+	}
+	withCause(cause) {
+		this.cause = cause;
+		return this;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			details: this.details
+		};
+	}
+};
+Object.freeze({ [Symbol("crust.finished")]: true });
+/**
+* Snapshot subprocess protocol used by first-party build tooling.
+*
+* When set to a non-empty file path, `.execute()` prepares the command tree,
+* validates its documentation sections, optionally runs Extension build hooks when the
+* build output directory is set, writes its final JSON snapshot and Build Report, and exits
+* without dispatching a Command Action. In-process callers use `Crust.snapshot()`.
+*
+* Only source entries run by `crust build` honor it: finished Bun/Node bundles carry
+* `process.env.CRUST_INTERNAL_BUILD === "1"` as a literal and compile the protocol out;
+* packaged Deno bundles set the `isPackagedBuild()` marker and skip it without
+* reading the environment.
+*/
+const SNAPSHOT_PATH_ENV = "CRUST_INTERNAL_SNAPSHOT_PATH";
+//#endregion
+//#region ../core/dist/index.js
+/** Mint an Extension identity from any non-blank, trimmed string. */
+function defineExtensionId(id) {
+	if (!id.trim() || id !== id.trim()) throw new CrustError("DEFINITION", "Extension id must be a non-empty, trimmed string", {
+		subject: "extension",
+		reason: "empty-id"
+	});
+	return id;
 }
 //#endregion
 //#region ../utils/dist/process.js
@@ -1766,11 +1718,42 @@ function getWindowsShimCommand(command, args, shell, platform = process.platform
 	};
 }
 /**
+* @internal Kill a POSIX process group (spawned with `detached: true`) or a
+* live Windows process tree. Descendants that leave the group are not reached.
+* If POSIX group signaling fails, try the direct child before rethrowing.
+*/
+function killProcessTree(child) {
+	if (child.pid === void 0) return;
+	if (process.platform === "win32") {
+		if (child.exitCode === null && child.signalCode === null) {
+			const result = spawnSync("taskkill", [
+				"/pid",
+				String(child.pid),
+				"/T",
+				"/F"
+			], {
+				stdio: "ignore",
+				timeout: 1e4
+			});
+			if (result.error || result.status !== 0) child.kill("SIGKILL");
+		}
+		return;
+	}
+	try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch (error) {
+		if (error.code === "ESRCH") return;
+		child.kill("SIGKILL");
+		throw error;
+	}
+}
+/**
 * Spawn a process and wait for it to exit without imposing an error policy.
 *
-* On Windows, the automatic `.cmd`/`.bat` workaround escapes arguments for
-* `cmd.exe`; unsafe shell-expansion characters throw before spawning. Explicit
-* `shell: true` calls are passed through unchanged and own their shell escaping.
+* On Windows, the automatic `.cmd`/`.bat` workaround supports command shims
+* forwarding arguments through `%*`, not arbitrary batch files consuming `%1`.
+* Unsafe shell-expansion characters throw before spawning. Explicit `shell: true`
+* calls are passed through unchanged and own their shell escaping.
 */
 async function runProcess(command, args = [], options = {}) {
 	const windowsShimCommand = getWindowsShimCommand(command, args, options.shell);
@@ -1785,18 +1768,39 @@ async function runProcess(command, args = [], options = {}) {
 			collectStdout ? "pipe" : "ignore",
 			"pipe"
 		] : "inherit",
+		detached: options.timeout !== void 0 && process.platform !== "win32",
 		windowsVerbatimArguments: windowsShimCommand?.windowsVerbatimArguments
 	});
-	const [stdout, stderr, [exitCode]] = await Promise.all([
-		collectStdout ? text(proc.stdout) : "",
-		collect ? text(proc.stderr) : "",
-		once(proc, "close")
-	]);
-	return {
-		exitCode,
-		stdout,
-		stderr
-	};
+	let timer;
+	const deadline = new Promise((_, reject) => {
+		if (options.timeout === void 0) return;
+		const timeout = options.timeout;
+		timer = setTimeout(() => {
+			let failure = /* @__PURE__ */ new Error(`${[command, ...args].join(" ")} did not exit within ${timeout} ms and was killed.`);
+			try {
+				killProcessTree(proc);
+			} catch (cause) {
+				failure = new Error("Process-tree cleanup failed after timeout.", { cause });
+			}
+			proc.stdout?.destroy();
+			proc.stderr?.destroy();
+			reject(failure);
+		}, timeout);
+	});
+	try {
+		const [stdout, stderr, [exitCode]] = await Promise.race([Promise.all([
+			collectStdout ? text(proc.stdout) : "",
+			collect ? text(proc.stderr) : "",
+			once(proc, "close")
+		]), deadline]);
+		return {
+			exitCode,
+			stdout,
+			stderr
+		};
+	} finally {
+		clearTimeout(timer);
+	}
 }
 /** Resolve a bare executable name from PATH (and PATHEXT on Windows). */
 function which(command) {
@@ -1818,47 +1822,902 @@ function which(command) {
 	return null;
 }
 //#endregion
-//#region src/utils/build-helpers.ts
-const BUILD_RUNTIMES = [
-	"bun",
-	"deno",
-	"node"
-];
-const BUN_TARGETS = {
-	runtime: "Bun",
-	targets: [
-		"bun-linux-x64",
-		"bun-linux-arm64",
-		"bun-linux-x64-musl",
-		"bun-linux-arm64-musl",
-		"bun-darwin-x64",
-		"bun-darwin-arm64",
-		"bun-windows-x64",
-		"bun-windows-arm64"
-	],
-	info: {
-		"bun-linux-x64": {
-			alias: "linux-x64",
-			platformKey: "linux-x64",
-			os: "linux",
-			cpu: "x64",
-			libc: "glibc"
-		},
-		"bun-linux-arm64": {
-			alias: "linux-arm64",
-			platformKey: "linux-arm64",
-			os: "linux",
-			cpu: "arm64",
-			libc: "glibc"
-		},
-		"bun-linux-x64-musl": {
-			alias: "linux-x64-musl",
-			platformKey: "linux-x64-musl",
-			os: "linux",
-			cpu: "x64",
-			libc: "musl"
-		},
-		"bun-linux-arm64-musl": {
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
+var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var LRUCache = class {
+		constructor() {
+			this.max = 1e3;
+			this.map = /* @__PURE__ */ new Map();
+		}
+		get(key) {
+			const value = this.map.get(key);
+			if (value === void 0) return;
+			else {
+				this.map.delete(key);
+				this.map.set(key, value);
+				return value;
+			}
+		}
+		delete(key) {
+			return this.map.delete(key);
+		}
+		set(key, value) {
+			if (!this.delete(key) && value !== void 0) {
+				if (this.map.size >= this.max) {
+					const firstKey = this.map.keys().next().value;
+					this.delete(firstKey);
+				}
+				this.map.set(key, value);
+			}
+			return this;
+		}
+	};
+	module.exports = LRUCache;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
+var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const looseOption = Object.freeze({ loose: true });
+	const emptyOpts = Object.freeze({});
+	const parseOptions = (options) => {
+		if (!options) return emptyOpts;
+		if (typeof options !== "object") return looseOption;
+		return options;
+	};
+	module.exports = parseOptions;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		MAX_LENGTH: 256,
+		MAX_SAFE_COMPONENT_LENGTH: 16,
+		MAX_SAFE_BUILD_LENGTH: 250,
+		MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 
+		/* istanbul ignore next */ 9007199254740991,
+		RELEASE_TYPES: [
+			"major",
+			"premajor",
+			"minor",
+			"preminor",
+			"patch",
+			"prepatch",
+			"prerelease"
+		],
+		SEMVER_SPEC_VERSION: "2.0.0",
+		FLAG_INCLUDE_PRERELEASE: 1,
+		FLAG_LOOSE: 2
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
+var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
+var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
+	const debug = require_debug();
+	exports = module.exports = {};
+	const re = exports.re = [];
+	const safeRe = exports.safeRe = [];
+	const src = exports.src = [];
+	const safeSrc = exports.safeSrc = [];
+	const t = exports.t = {};
+	let R = 0;
+	const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+	const safeRegexReplacements = [
+		["\\s", 1],
+		["\\d", MAX_LENGTH],
+		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+	];
+	const makeSafeRegex = (value) => {
+		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+		return value;
+	};
+	const createToken = (name, value, isGlobal) => {
+		const safe = makeSafeRegex(value);
+		const index = R++;
+		debug(name, index, value);
+		t[name] = index;
+		src[index] = value;
+		safeSrc[index] = safe;
+		re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+	};
+	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+	createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+	createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+	createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+	createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+	createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+	createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+	createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+	createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+	createToken("GTLT", "((?:<|>)?=?)");
+	createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+	createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+	createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+	createToken("COERCERTL", src[t.COERCE], true);
+	createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+	createToken("LONETILDE", "(?:~>?)");
+	createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+	exports.tildeTrimReplace = "$1~";
+	createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+	createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("LONECARET", "(?:\\^)");
+	createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+	exports.caretTrimReplace = "$1^";
+	createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+	createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+	createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+	createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+	exports.comparatorTrimReplace = "$1$2$3";
+	createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+	createToken("STAR", "(<|>)?=?\\s*\\*");
+	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
+var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const numeric = /^[0-9]+$/;
+	const compareIdentifiers = (a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+		const anum = numeric.test(a);
+		const bnum = numeric.test(b);
+		if (anum && bnum) {
+			a = +a;
+			b = +b;
+		}
+		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+	};
+	const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+	module.exports = {
+		compareIdentifiers,
+		rcompareIdentifiers
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
+var require_semver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const debug = require_debug();
+	const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+	const { safeRe: re, t } = require_re();
+	const parseOptions = require_parse_options();
+	const { compareIdentifiers } = require_identifiers();
+	const isPrereleaseIdentifier = (prerelease, identifier) => {
+		const identifiers = identifier.split(".");
+		if (identifiers.length > prerelease.length) return false;
+		for (let i = 0; i < identifiers.length; i++) if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) return false;
+		return true;
+	};
+	module.exports = class SemVer {
+		constructor(version, options) {
+			options = parseOptions(options);
+			if (version instanceof SemVer) {
+				if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
+				else version = version.version;
+			} else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+			debug("SemVer", version, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+			if (!m) throw new TypeError(`Invalid Version: ${version}`);
+			this.raw = version;
+			this.major = +m[1];
+			this.minor = +m[2];
+			this.patch = +m[3];
+			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
+			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
+			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
+			if (!m[4]) this.prerelease = [];
+			else this.prerelease = m[4].split(".").map((id) => {
+				if (/^[0-9]+$/.test(id)) {
+					const num = +id;
+					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+				}
+				return id;
+			});
+			this.build = m[5] ? m[5].split(".") : [];
+			this.format();
+		}
+		format() {
+			this.version = `${this.major}.${this.minor}.${this.patch}`;
+			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+			return this.version;
+		}
+		toString() {
+			return this.version;
+		}
+		compare(other) {
+			debug("SemVer.compare", this.version, this.options, other);
+			if (!(other instanceof SemVer)) {
+				if (typeof other === "string" && other === this.version) return 0;
+				other = new SemVer(other, this.options);
+			}
+			if (other.version === this.version) return 0;
+			return this.compareMain(other) || this.comparePre(other);
+		}
+		compareMain(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.major < other.major) return -1;
+			if (this.major > other.major) return 1;
+			if (this.minor < other.minor) return -1;
+			if (this.minor > other.minor) return 1;
+			if (this.patch < other.patch) return -1;
+			if (this.patch > other.patch) return 1;
+			return 0;
+		}
+		comparePre(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.prerelease.length && !other.prerelease.length) return -1;
+			else if (!this.prerelease.length && other.prerelease.length) return 1;
+			else if (!this.prerelease.length && !other.prerelease.length) return 0;
+			let i = 0;
+			do {
+				const a = this.prerelease[i];
+				const b = other.prerelease[i];
+				debug("prerelease compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		compareBuild(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			let i = 0;
+			do {
+				const a = this.build[i];
+				const b = other.build[i];
+				debug("build compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		inc(release, identifier, identifierBase) {
+			if (release.startsWith("pre")) {
+				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
+				if (identifier) {
+					const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
+				}
+			}
+			switch (release) {
+				case "premajor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor = 0;
+					this.major++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "preminor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prepatch":
+					this.prerelease.length = 0;
+					this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prerelease":
+					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "release":
+					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
+					this.prerelease.length = 0;
+					break;
+				case "major":
+					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+					this.minor = 0;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "minor":
+					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "patch":
+					if (this.prerelease.length === 0) this.patch++;
+					this.prerelease = [];
+					break;
+				case "pre": {
+					const base = Number(identifierBase) ? 1 : 0;
+					if (this.prerelease.length === 0) this.prerelease = [base];
+					else {
+						let i = this.prerelease.length;
+						while (--i >= 0) if (typeof this.prerelease[i] === "number") {
+							this.prerelease[i]++;
+							i = -2;
+						}
+						if (i === -1) {
+							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
+							this.prerelease.push(base);
+						}
+					}
+					if (identifier) {
+						let prerelease = [identifier, base];
+						if (identifierBase === false) prerelease = [identifier];
+						if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+							const prereleaseBase = this.prerelease[identifier.split(".").length];
+							if (isNaN(prereleaseBase)) this.prerelease = prerelease;
+						} else this.prerelease = prerelease;
+					}
+					break;
+				}
+				default: throw new Error(`invalid increment argument: ${release}`);
+			}
+			this.raw = this.format();
+			if (this.build.length) this.raw += `+${this.build.join(".")}`;
+			return this;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
+var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SemVer = require_semver();
+	const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+	module.exports = compare;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
+var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const eq = (a, b, loose) => compare(a, b, loose) === 0;
+	module.exports = eq;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
+var require_neq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const neq = (a, b, loose) => compare(a, b, loose) !== 0;
+	module.exports = neq;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
+var require_gt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const gt = (a, b, loose) => compare(a, b, loose) > 0;
+	module.exports = gt;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
+var require_gte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+	module.exports = gte;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
+var require_lt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const lt = (a, b, loose) => compare(a, b, loose) < 0;
+	module.exports = lt;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
+var require_lte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+	module.exports = lte;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
+var require_cmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const eq = require_eq();
+	const neq = require_neq();
+	const gt = require_gt();
+	const gte = require_gte();
+	const lt = require_lt();
+	const lte = require_lte();
+	const cmp = (a, op, b, loose) => {
+		switch (op) {
+			case "===":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a === b;
+			case "!==":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a !== b;
+			case "":
+			case "=":
+			case "==": return eq(a, b, loose);
+			case "!=": return neq(a, b, loose);
+			case ">": return gt(a, b, loose);
+			case ">=": return gte(a, b, loose);
+			case "<": return lt(a, b, loose);
+			case "<=": return lte(a, b, loose);
+			default: throw new TypeError(`Invalid operator: ${op}`);
+		}
+	};
+	module.exports = cmp;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
+var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ANY = Symbol("SemVer ANY");
+	module.exports = class Comparator {
+		static get ANY() {
+			return ANY;
+		}
+		constructor(comp, options) {
+			options = parseOptions(options);
+			if (comp instanceof Comparator) {
+				if (comp.loose === !!options.loose) return comp;
+				else comp = comp.value;
+			}
+			comp = comp.trim().split(/\s+/).join(" ");
+			debug("comparator", comp, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.parse(comp);
+			if (this.semver === ANY) this.value = "";
+			else this.value = this.operator + this.semver.version;
+			debug("comp", this);
+		}
+		parse(comp) {
+			const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+			const m = comp.match(r);
+			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+			this.operator = m[1] !== void 0 ? m[1] : "";
+			if (this.operator === "=") this.operator = "";
+			if (!m[2]) this.semver = ANY;
+			else this.semver = new SemVer(m[2], this.options.loose);
+		}
+		toString() {
+			return this.value;
+		}
+		test(version) {
+			debug("Comparator.test", version, this.options.loose);
+			if (this.semver === ANY || version === ANY) return true;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			return cmp(version, this.operator, this.semver, this.options);
+		}
+		intersects(comp, options) {
+			if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
+			if (this.operator === "") {
+				if (this.value === "") return true;
+				return new Range(comp.value, options).test(this.value);
+			} else if (comp.operator === "") {
+				if (comp.value === "") return true;
+				return new Range(this.value, options).test(comp.semver);
+			}
+			options = parseOptions(options);
+			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
+			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+			if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+			if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+			return false;
+		}
+	};
+	const parseOptions = require_parse_options();
+	const { safeRe: re, t } = require_re();
+	const cmp = require_cmp();
+	const debug = require_debug();
+	const SemVer = require_semver();
+	const Range = require_range();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
+var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SPACE_CHARACTERS = /\s+/g;
+	module.exports = class Range {
+		constructor(range, options) {
+			options = parseOptions(options);
+			if (range instanceof Range) {
+				if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+				else return new Range(range.raw, options);
+			}
+			if (range instanceof Comparator) {
+				this.raw = range.value;
+				this.set = [[range]];
+				this.formatted = void 0;
+				return this;
+			}
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+			this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+			if (this.set.length > 1) {
+				const first = this.set[0];
+				this.set = this.set.filter((c) => !isNullSet(c[0]));
+				if (this.set.length === 0) this.set = [first];
+				else if (this.set.length > 1) {
+					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
+						this.set = [c];
+						break;
+					}
+				}
+			}
+			this.formatted = void 0;
+		}
+		get range() {
+			if (this.formatted === void 0) {
+				this.formatted = "";
+				for (let i = 0; i < this.set.length; i++) {
+					if (i > 0) this.formatted += "||";
+					const comps = this.set[i];
+					for (let k = 0; k < comps.length; k++) {
+						if (k > 0) this.formatted += " ";
+						this.formatted += comps[k].toString().trim();
+					}
+				}
+			}
+			return this.formatted;
+		}
+		format() {
+			return this.range;
+		}
+		toString() {
+			return this.range;
+		}
+		parseRange(range) {
+			range = range.replace(BUILDSTRIPRE, "");
+			const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
+			const cached = cache.get(memoKey);
+			if (cached) return cached;
+			const loose = this.options.loose;
+			const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+			debug("hyphen replace", range);
+			range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+			debug("comparator trim", range);
+			range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+			debug("tilde trim", range);
+			range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+			debug("caret trim", range);
+			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+			if (loose) rangeList = rangeList.filter((comp) => {
+				debug("loose invalid filter", comp, this.options);
+				return !!comp.match(re[t.COMPARATORLOOSE]);
+			});
+			debug("range list", rangeList);
+			const rangeMap = /* @__PURE__ */ new Map();
+			const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+			for (const comp of comparators) {
+				if (isNullSet(comp)) return [comp];
+				rangeMap.set(comp.value, comp);
+			}
+			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+			const result = [...rangeMap.values()];
+			cache.set(memoKey, result);
+			return result;
+		}
+		intersects(range, options) {
+			if (!(range instanceof Range)) throw new TypeError("a Range is required");
+			return this.set.some((thisComparators) => {
+				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+						return rangeComparators.every((rangeComparator) => {
+							return thisComparator.intersects(rangeComparator, options);
+						});
+					});
+				});
+			});
+		}
+		test(version) {
+			if (!version) return false;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
+			return false;
+		}
+	};
+	const cache = new (require_lrucache())();
+	const parseOptions = require_parse_options();
+	const Comparator = require_comparator();
+	const debug = require_debug();
+	const SemVer = require_semver();
+	const { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+	const BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
+	const isNullSet = (c) => c.value === "<0.0.0-0";
+	const isAny = (c) => c.value === "";
+	const isSatisfiable = (comparators, options) => {
+		let result = true;
+		const remainingComparators = comparators.slice();
+		let testComparator = remainingComparators.pop();
+		while (result && remainingComparators.length) {
+			result = remainingComparators.every((otherComparator) => {
+				return testComparator.intersects(otherComparator, options);
+			});
+			testComparator = remainingComparators.pop();
+		}
+		return result;
+	};
+	const parseComparator = (comp, options) => {
+		comp = comp.replace(re[t.BUILD], "");
+		debug("comp", comp, options);
+		comp = replaceCarets(comp, options);
+		debug("caret", comp);
+		comp = replaceTildes(comp, options);
+		debug("tildes", comp);
+		comp = replaceXRanges(comp, options);
+		debug("xrange", comp);
+		comp = replaceStars(comp, options);
+		debug("stars", comp);
+		return comp;
+	};
+	const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+	const invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
+	const replaceTildes = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+	};
+	const replaceTilde = (comp, options) => {
+		const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+		const z = options.includePrerelease ? "-0" : "";
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("tilde", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+			else if (isX(p)) ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+			else if (pr) {
+				debug("replaceTilde pr", pr);
+				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+			debug("tilde return", ret);
+			return ret;
+		});
+	};
+	const replaceCarets = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+	};
+	const replaceCaret = (comp, options) => {
+		debug("caret", comp, options);
+		const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+		const z = options.includePrerelease ? "-0" : "";
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("caret", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+			else if (isX(p)) {
+				if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+			} else if (pr) {
+				debug("replaceCaret pr", pr);
+				if (M === "0") {
+					if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+					else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+				} else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+			} else {
+				debug("no pr");
+				if (M === "0") {
+					if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+					else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+				} else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+			}
+			debug("caret return", ret);
+			return ret;
+		});
+	};
+	const replaceXRanges = (comp, options) => {
+		debug("replaceXRanges", comp, options);
+		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+	};
+	const replaceXRange = (comp, options) => {
+		comp = comp.trim();
+		const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+		return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+			debug("xRange", comp, ret, gtlt, M, m, p, pr);
+			if (invalidXRangeOrder(M, m, p)) return comp;
+			const xM = isX(M);
+			const xm = xM || isX(m);
+			const xp = xm || isX(p);
+			const anyX = xp;
+			if (gtlt === "=" && anyX) gtlt = "";
+			pr = options.includePrerelease ? "-0" : "";
+			if (xM) {
+				if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+				else ret = "*";
+			} else if (gtlt && anyX) {
+				if (xm) m = 0;
+				p = 0;
+				if (gtlt === ">") {
+					gtlt = ">=";
+					if (xm) {
+						M = +M + 1;
+						m = 0;
+						p = 0;
+					} else {
+						m = +m + 1;
+						p = 0;
+					}
+				} else if (gtlt === "<=") {
+					gtlt = "<";
+					if (xm) M = +M + 1;
+					else m = +m + 1;
+				}
+				if (gtlt === "<") pr = "-0";
+				ret = `${gtlt + M}.${m}.${p}${pr}`;
+			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+			debug("xRange return", ret);
+			return ret;
+		});
+	};
+	const replaceStars = (comp, options) => {
+		debug("replaceStars", comp, options);
+		return comp.trim().replace(re[t.STAR], "");
+	};
+	const replaceGTE0 = (comp, options) => {
+		debug("replaceGTE0", comp, options);
+		return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+	};
+	const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+		if (isX(fM)) from = "";
+		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+		else if (fpr) from = `>=${from}`;
+		else from = `>=${from}${incPr ? "-0" : ""}`;
+		if (isX(tM)) to = "";
+		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
+		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
+		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
+		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	};
+	const testSet = (set, version, options) => {
+		for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
+		if (version.prerelease.length && !options.includePrerelease) {
+			for (let i = 0; i < set.length; i++) {
+				debug(set[i].semver);
+				if (set[i].semver === Comparator.ANY) continue;
+				if (set[i].semver.prerelease.length > 0) {
+					const allowed = set[i].semver;
+					if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+				}
+			}
+			return false;
+		}
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
+var require_satisfies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Range = require_range();
+	const satisfies = (version, range, options) => {
+		try {
+			range = new Range(range, options);
+		} catch (er) {
+			return false;
+		}
+		return range.test(version);
+	};
+	module.exports = satisfies;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SemVer = require_semver();
+	const parse = (version, options, throwErrors = false) => {
+		if (version instanceof SemVer) return version;
+		try {
+			return new SemVer(version, options);
+		} catch (er) {
+			if (!throwErrors) return null;
+			throw er;
+		}
+	};
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
+var require_valid$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const parse = require_parse();
+	const valid = (version, options) => {
+		const v = parse(version, options);
+		return v ? v.version : null;
+	};
+	module.exports = valid;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
+var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Range = require_range();
+	const validRange = (range, options) => {
+		try {
+			return new Range(range, options).range || "*";
+		} catch (er) {
+			return null;
+		}
+	};
+	module.exports = validRange;
+}));
+//#endregion
+//#region package.json
+var import_satisfies = /* @__PURE__ */ __toESM(require_satisfies(), 1);
+var import_valid = /* @__PURE__ */ __toESM(require_valid$1(), 1);
+var import_valid$1 = /* @__PURE__ */ __toESM(require_valid(), 1);
+var optionalDependencies = {
+	"@tsdown/exe": "0.23.0",
+	"tsdown": "0.23.0"
+};
+//#endregion
+//#region src/utils/build-helpers.ts
+const BUILD_RUNTIMES = [
+	"bun",
+	"deno",
+	"node"
+];
+const BUN_TARGETS = {
+	runtime: "Bun",
+	targets: [
+		"bun-linux-x64",
+		"bun-linux-arm64",
+		"bun-linux-x64-musl",
+		"bun-linux-arm64-musl",
+		"bun-darwin-x64",
+		"bun-darwin-arm64",
+		"bun-windows-x64",
+		"bun-windows-arm64"
+	],
+	info: {
+		"bun-linux-x64": {
+			alias: "linux-x64",
+			platformKey: "linux-x64",
+			os: "linux",
+			cpu: "x64",
+			libc: "glibc"
+		},
+		"bun-linux-arm64": {
+			alias: "linux-arm64",
+			platformKey: "linux-arm64",
+			os: "linux",
+			cpu: "arm64",
+			libc: "glibc"
+		},
+		"bun-linux-x64-musl": {
+			alias: "linux-x64-musl",
+			platformKey: "linux-x64-musl",
+			os: "linux",
+			cpu: "x64",
+			libc: "musl"
+		},
+		"bun-linux-arm64-musl": {
 			alias: "linux-arm64-musl",
 			platformKey: "linux-arm64-musl",
 			os: "linux",
@@ -1942,8 +2801,57 @@ const DENO_TARGETS = {
 		}
 	}
 };
-/** `--target` value that stands for this machine's canonical target. */
-const HOST_TARGET = "host";
+const NODE_TARGETS = {
+	runtime: "Node",
+	targets: [
+		"linux-x64",
+		"linux-arm64",
+		"darwin-x64",
+		"darwin-arm64",
+		"win-x64",
+		"win-arm64"
+	],
+	info: {
+		"linux-x64": {
+			alias: "linux-x64",
+			platformKey: "linux-x64",
+			os: "linux",
+			cpu: "x64",
+			libc: "glibc"
+		},
+		"linux-arm64": {
+			alias: "linux-arm64",
+			platformKey: "linux-arm64",
+			os: "linux",
+			cpu: "arm64",
+			libc: "glibc"
+		},
+		"darwin-x64": {
+			alias: "darwin-x64",
+			platformKey: "darwin-x64",
+			os: "darwin",
+			cpu: "x64"
+		},
+		"darwin-arm64": {
+			alias: "darwin-arm64",
+			platformKey: "darwin-arm64",
+			os: "darwin",
+			cpu: "arm64"
+		},
+		"win-x64": {
+			alias: "windows-x64",
+			platformKey: "win32-x64",
+			os: "win32",
+			cpu: "x64"
+		},
+		"win-arm64": {
+			alias: "windows-arm64",
+			platformKey: "win32-arm64",
+			os: "win32",
+			cpu: "arm64"
+		}
+	}
+};
 /**
 * Canonical targets for `--target` inputs, deduplicated in input order. No
 * inputs means every target of the table; `host` means this machine's target.
@@ -2043,14 +2951,234 @@ function bunCompileTarget(target, runner, host = hostTarget(BUN_TARGETS)) {
 /**
 * Refuse the host target when only the `BUN_BE_BUN` fallback runner is
 * available and no `-baseline` alias can stand in for it (arm64 hosts).
+* Pass the selected `runner` to judge that compiler instead of looking up
+* `bun` on PATH again.
 */
-function assertTargetsBuildableWithoutBun(targets, host = hostTarget(BUN_TARGETS)) {
-	if (host === null || !targets.includes(host) || bunBaselineAlias(host) !== null || which("bun") !== null) return;
+function assertTargetsBuildableWithoutBun(targets, host = hostTarget(BUN_TARGETS), runner) {
+	const externalBun = runner ? runner.env.BUN_BE_BUN !== "1" : which("bun") !== null;
+	if (host === null || !targets.includes(host) || bunBaselineAlias(host) !== null || externalBun) return;
 	const others = targets.filter((target) => target !== host);
 	const alternative = others.length > 0 ? `pass --target with the other targets (e.g. ${others.map((target) => `--target ${target}`).join(" ")})` : "build a different target";
 	throw new Error(`Cannot build ${host} without a separate bun executable on PATH.\n  Bun reuses the running crust executable as the base for its own platform, which yields a binary that crashes on start.
   Install Bun (https://bun.sh), or ${alternative}.`);
 }
+/** The external `deno` on PATH; Deno has no embedded fallback. */
+function resolveDenoBuildRunner() {
+	const denoPath = which("deno");
+	if (!denoPath) throw new Error("Deno is required for the deno runtime but was not found on PATH.\n  Install Deno from https://deno.com/ and try again.");
+	return {
+		command: denoPath,
+		env: { ...process.env }
+	};
+}
+/** The external `node` on PATH, which runs tsdown's executable builder; there is no embedded fallback. */
+function resolveNodeBuildRunner() {
+	const nodePath = which("node");
+	if (!nodePath) throw new Error("Node is required for node standalone binaries but was not found on PATH.\n  Binaries embed the selected node's version; install Node (https://nodejs.org) or put it first on PATH with your version manager.");
+	return {
+		command: nodePath,
+		env: { ...process.env }
+	};
+}
+const RUNTIME_LABELS = {
+	bun: "Bun",
+	deno: "Deno",
+	node: "Node"
+};
+const COMPILER_VERSION_TIMEOUT_MS = 3e4;
+/**
+* Runtime version reported by the runner itself (`<command> --version`), never
+* the runtime hosting this process: `bun` prints `1.4.2`, `deno` prints
+* `deno 2.9.6 (…)`, `node` prints `v24.21.0`. Under the `BUN_BE_BUN` fallback
+* this is the embedded Bun, which is the compiler. `cwd` must be the directory
+* compilation runs in: a version-manager shim picks its runtime from it. A
+* probe still running after {@link COMPILER_VERSION_TIMEOUT_MS} is killed and
+* fails the build, before `.crust/` is replaced.
+*/
+async function readCompilerVersion(runtime, runner, cwd) {
+	const { exitCode, stdout, stderr } = await runProcess(runner.command, ["--version"], {
+		env: runner.env,
+		cwd,
+		stdio: "collect",
+		timeout: COMPILER_VERSION_TIMEOUT_MS
+	});
+	const reported = runtime === "deno" ? /^deno (\S+)/.exec(stdout.trim())?.[1] : stdout.trim();
+	const version = exitCode === 0 && reported !== void 0 ? (0, import_valid.default)(reported) : null;
+	if (version === null) {
+		const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+		throw new Error(`Could not read the ${RUNTIME_LABELS[runtime]} version from ${runner.command} --version (exit ${exitCode})${output ? `:\n${output}` : "."}`);
+	}
+	return version;
+}
+function isVersionRange(value) {
+	return typeof value === "string" && (0, import_valid$1.default)(value) !== null;
+}
+/**
+* Check the selected compiler against the project's `engines.<runtime>` with
+* npm semver semantics. An absent constraint allows any version; an exact
+* value is a requirement, not a request to install that version.
+*/
+function assertCompilerSatisfiesEngines(compiler, userPackageJson) {
+	if (userPackageJson === void 0 || !isJsonObject(userPackageJson)) return;
+	const { engines } = userPackageJson;
+	if (engines === void 0) return;
+	if (!isJsonObject(engines)) throw new Error("package.json engines must be an object of runtime version ranges.");
+	const constraint = engines[compiler.runtime];
+	if (constraint === void 0) return;
+	const field = `package.json engines.${compiler.runtime}`;
+	if (!isVersionRange(constraint)) throw new Error(`${field} is not a valid semver range: ${JSON.stringify(constraint)}.\n  Use an exact version or range such as "1.4.2" or ">=1.4.0".`);
+	if (!(0, import_satisfies.default)(compiler.version, constraint)) {
+		const label = RUNTIME_LABELS[compiler.runtime];
+		throw new Error(`${label} ${compiler.version} (${compiler.runner.command}) does not satisfy ${field} "${constraint}".\n  Binaries embed the selected compiler's ${label} version; crust does not install or upgrade it.\n  Put a matching ${compiler.runtime} first on PATH (e.g. with your version manager), or update ${field}.`);
+	}
+}
+/**
+* Select the binary compiler once for a build: the Bun runner (external bun
+* first, then the embedded fallback) or the external deno. Returns its actual
+* version, read in the project directory `cwd`, after validating it against
+* `engines`. Pass `runner` and the same `cwd` on to the `exec*`/`buildEntrypoint`
+* helpers so every step uses this same compiler.
+*/
+async function resolveBinaryCompiler(runtime, userPackageJson, cwd) {
+	const runner = runtime === "bun" ? resolveBunBuildRunner() : resolveDenoBuildRunner();
+	const compiler = {
+		runtime,
+		runner,
+		version: await readCompilerVersion(runtime, runner, cwd)
+	};
+	assertCompilerSatisfiesEngines(compiler, userPackageJson);
+	return compiler;
+}
+/**
+* Crust's own optional dependencies that build Node standalone binaries.
+* Crust's staged root and platform packages declare them
+* (scripts/stage-node-exe-dependencies.ts) so an installed crust resolves them
+* next to itself; an install that skipped them only affects Node binaries.
+*/
+const NODE_EXE_BACKEND_PACKAGES = ["tsdown", "@tsdown/exe"];
+/**
+* A file of Crust's own installation that the backend is resolved from, never
+* the project or PATH. A compiled crust serves its modules from Bun's virtual
+* filesystem (`/$bunfs/`, `B:/~BUN/` on Windows), so there it is the
+* executable, inside its platform package.
+*/
+function crustInstallPath(moduleUrl = import.meta.url, execPath = process.execPath) {
+	return /^file:\/\/\/(?:\$bunfs|[A-Za-z]:\/~BUN)\//.test(moduleUrl) ? execPath : fileURLToPath(moduleUrl);
+}
+/**
+* `<dir>/node_modules/<name>/package.json` for the nearest `dir` at or above
+* `from`: Node's node_modules lookup without its NODE_PATH and global-folder
+* fallbacks, so only an installation next to `from` can supply the package.
+* Package managers hoist crust's backend into the project's node_modules, so
+* the found package may be the project's own: callers check its version.
+*/
+function findInstalledPackageJson(from, name) {
+	for (let dir = from;; dir = dirname(dir)) {
+		const candidate = join(dir, "node_modules", name, "package.json");
+		if (existsSync(candidate)) return candidate;
+		if (dirname(dir) === dir) return null;
+	}
+}
+function isVersionedPackageJson(value) {
+	return isJsonObject(value) && typeof value.version === "string";
+}
+function isTsdownPackageJson(value) {
+	return isVersionedPackageJson(value) && value.engines !== void 0 && isJsonObject(value.engines) && value.engines.node !== void 0 && isVersionRange(value.engines.node);
+}
+function createNodeExeProbeScript(tsdownPackageJson) {
+	return `// Generated by crust build to read tsdown's executable minimum; deleted when it exits.
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+const internal = createRequire(${JSON.stringify(tsdownPackageJson)}).resolve("tsdown/internal");
+console.log((await import(pathToFileURL(internal).href)).NODE_SEA_MIN_VERSION);
+`;
+}
+const NODE_TOOLCHAIN_GUIDANCE = "  Binaries embed the selected node's version; crust does not install or upgrade it.\n  Put a supported node first on PATH (e.g. with your version manager).";
+/**
+* Checks the selected Node against the installed backend's two separate
+* requirements: tsdown's package `engines.node` and its executable builder's
+* minimum (skipped while unknown). Both come from the installed tsdown, not
+* from this file.
+*/
+function assertNodeExeBackendSupports(compiler, backend) {
+	const selected = `Node ${compiler.version} (${compiler.runner.command})`;
+	if (!(0, import_satisfies.default)(compiler.version, backend.engines)) throw new Error(`${selected} is not supported by tsdown ${backend.version}, which builds node standalone binaries: its package requires Node "${backend.engines}".\n${NODE_TOOLCHAIN_GUIDANCE}`);
+	if (backend.seaMinVersion !== void 0 && !(0, import_satisfies.default)(compiler.version, `>=${backend.seaMinVersion}`)) throw new Error(`${selected} cannot build standalone executables: tsdown ${backend.version}'s executable builder requires Node ${backend.seaMinVersion} or later.\n${NODE_TOOLCHAIN_GUIDANCE}`);
+}
+/**
+* Finds Crust's installed tsdown and @tsdown/exe from `installPath`, at the
+* versions its package.json `optionalDependencies` pin, and validates the
+* selected Node against tsdown's requirements, loading the executable
+* builder's minimum under that Node. `cwd` is the project
+* directory, as for every other compiler step.
+*/
+async function resolveNodeExeBackend(compiler, cwd, installPath = crustInstallPath()) {
+	const reinstall = `  @crustjs/crust ships ${NODE_EXE_BACKEND_PACKAGES.join(" and ")} as optional dependencies, which package managers skip when optional dependencies are disabled or the installing node does not satisfy tsdown's engines.\n  Reinstall @crustjs/crust with optional dependencies enabled under a node that can build Node binaries (e.g. the one on PATH here).`;
+	const packageJsonPath = findInstalledPackageJson(dirname(installPath), "tsdown");
+	if (packageJsonPath === null) throw new Error(`tsdown, which builds node standalone binaries, is not installed with crust (${installPath}).\n${reinstall}`);
+	const exePackageJsonPath = findInstalledPackageJson(dirname(realpathSync(packageJsonPath)), "@tsdown/exe");
+	if (exePackageJsonPath === null) throw new Error(`@tsdown/exe is not installed beside crust's tsdown (${packageJsonPath}).\n${reinstall}`);
+	for (const [name, path] of [["tsdown", packageJsonPath], ["@tsdown/exe", exePackageJsonPath]]) {
+		const installed = JSON.parse(readFileSync(path, "utf8"));
+		const version = isVersionedPackageJson(installed) ? installed.version : "without a version";
+		const pinned = optionalDependencies[name];
+		if (!(0, import_satisfies.default)(version, pinned)) throw new Error(`${name} ${version} (${path}) is not the ${name} ${pinned} that crust builds node standalone binaries with.\n${reinstall}`);
+	}
+	const tsdownPackage = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	if (!isTsdownPackageJson(tsdownPackage)) throw new Error(`Unexpected tsdown package metadata in ${packageJsonPath}.\n${reinstall}`);
+	const backend = {
+		packageJsonPath,
+		version: tsdownPackage.version,
+		engines: tsdownPackage.engines.node
+	};
+	assertNodeExeBackendSupports(compiler, backend);
+	const workDir = await mkdtemp(join(tmpdir(), "crust-node-exe-probe-"));
+	try {
+		const scriptPath = join(workDir, "probe.mjs");
+		await writeFile(scriptPath, createNodeExeProbeScript(packageJsonPath));
+		const { exitCode, stdout, stderr } = await runProcess(compiler.runner.command, [scriptPath], {
+			env: compiler.runner.env,
+			cwd,
+			stdio: "collect"
+		});
+		const seaMinVersion = exitCode === 0 ? (0, import_valid.default)(stdout.trim()) : null;
+		if (seaMinVersion === null) {
+			const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+			throw new Error(`tsdown ${backend.version}'s executable builder could not be loaded with ${compiler.runner.command} (exit ${exitCode}).\n${reinstall}${output ? `\n${output}` : ""}`);
+		}
+		const resolved = {
+			...backend,
+			seaMinVersion
+		};
+		assertNodeExeBackendSupports(compiler, resolved);
+		return resolved;
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Select the Node binary compiler once for a build: the external `node`, its
+* version read in the project directory `cwd`, validated against the
+* project's `engines.node` and then the installed tsdown's requirements.
+* Pass it to {@link execNodeBinaryBuild} for every command and target.
+*/
+async function resolveNodeBinaryCompiler(userPackageJson, cwd) {
+	const runner = resolveNodeBuildRunner();
+	const compiler = {
+		runtime: "node",
+		runner,
+		version: await readCompilerVersion("node", runner, cwd)
+	};
+	assertCompilerSatisfiesEngines(compiler, userPackageJson);
+	return {
+		...compiler,
+		backend: await resolveNodeExeBackend(compiler, cwd)
+	};
+}
 /**
 * Module source the generated driver imports for a `crust.bunPlugins` specifier.
 *
@@ -2100,7 +3228,7 @@ if (!result.success) {
 	for (const log of result.logs) console.error(log);
 	process.exit(1);
 }
-if (options.build.target === "node") {
+if (!options.build.compile) {
 	if (result.outputs.length !== 1) {
 		// Same refusal as \`bun build --outfile\`: a file-type asset import yields entry + asset.
 		console.error("error: cannot write multiple output files without an output directory");
@@ -2110,7 +3238,7 @@ if (options.build.target === "node") {
 }
 `;
 }
-async function runBunPluginDriver(build, outfilePath, bunPlugins, envFiles, cwd) {
+async function runBunPluginDriver(build, outfilePath, bunPlugins, envFiles, cwd, runner) {
 	const driverPath = join(cwd, `.crust-build-${randomBytes(6).toString("hex")}.ts`);
 	await writeFile(driverPath, createBunPluginDriverScript({
 		plugins: bunPlugins.map((specifier) => ({
@@ -2121,7 +3249,7 @@ async function runBunPluginDriver(build, outfilePath, bunPlugins, envFiles, cwd)
 		outfile: outfilePath
 	}));
 	try {
-		await runBuildProcess(resolveBunBuildRunner(), [...toBunEnvFileArgs(envFiles), driverPath], outfilePath, cwd);
+		await runBuildProcess(runner, [...toBunEnvFileArgs(envFiles), driverPath], outfilePath, cwd);
 	} finally {
 		await rm(driverPath, { force: true });
 	}
@@ -2141,10 +3269,10 @@ async function runBunPluginDriver(build, outfilePath, bunPlugins, envFiles, cwd)
 * @param envFiles - Optional env files to load during build
 * @param bunPlugins - Bun bundler plugin specifiers; when present the build
 *   runs through the generated `Bun.build` driver instead of `bun build`
+* @param runner - The selected Bun compiler (`resolveBinaryCompiler`)
 * @throws {Error} If the build fails
 */
-async function execBuild(entryPath, outfilePath, minify, target, envFiles, cwd, bunPlugins = []) {
-	const runner = resolveBunBuildRunner();
+async function execBuild(entryPath, outfilePath, minify, target, envFiles, cwd, bunPlugins = [], runner = resolveBunBuildRunner()) {
 	const compileTarget = bunCompileTarget(target, runner);
 	if (bunPlugins.length > 0) {
 		await runBunPluginDriver({
@@ -2157,7 +3285,7 @@ async function execBuild(entryPath, outfilePath, minify, target, envFiles, cwd,
 				outfile: outfilePath,
 				autoloadBunfig: false
 			}
-		}, outfilePath, bunPlugins, envFiles, cwd);
+		}, outfilePath, bunPlugins, envFiles, cwd, runner);
 		return;
 	}
 	await runBuildProcess(runner, createBunCompileArgs(entryPath, outfilePath, minify, compileTarget, envFiles), outfilePath, cwd);
@@ -2201,22 +3329,33 @@ async function runBuildProcess(runner, args, outfilePath, cwd) {
 		throw new Error(`Build failed for ${outfilePath}${output ? `:\n${output}` : ""}`);
 	}
 }
-async function execNodeBuild(entryPath, outfilePath, minify, envFiles, cwd, bunPlugins = []) {
+/** Bundle a Node runtime package entry: ESM for Node behind `#!/usr/bin/env node`. */
+async function execNodeBuild(entryPath, outfilePath, minify, envFiles, cwd, bunPlugins = [], runner = resolveBunBuildRunner()) {
+	await execScriptBuild("node", entryPath, outfilePath, minify, envFiles, cwd, bunPlugins, runner);
+}
+/**
+* Bundle a Bun runtime package entry: Bun-targeted ESM behind
+* `#!/usr/bin/env bun`, so the installed bin launches with Bun rather than Node.
+*/
+async function execBunPackageBuild(entryPath, outfilePath, minify, envFiles, cwd, bunPlugins = [], runner = resolveBunBuildRunner()) {
+	await execScriptBuild("bun", entryPath, outfilePath, minify, envFiles, cwd, bunPlugins, runner);
+}
+async function execScriptBuild(target, entryPath, outfilePath, minify, envFiles, cwd, bunPlugins, runner) {
 	if (bunPlugins.length > 0) await runBunPluginDriver({
 		entrypoints: [entryPath],
 		minify,
 		env: "PUBLIC_*",
-		target: "node",
+		target,
 		format: "esm"
-	}, outfilePath, bunPlugins, envFiles, cwd);
-	else await runBuildProcess(resolveBunBuildRunner(), [
+	}, outfilePath, bunPlugins, envFiles, cwd, runner);
+	else await runBuildProcess(runner, [
 		"build",
 		...toBunEnvFileArgs(envFiles),
 		"--env=PUBLIC_*",
 		"--define",
 		CRUST_BUILD_DEFINE_ARG,
 		"--target",
-		"node",
+		target,
 		"--format",
 		"esm",
 		"--outfile",
@@ -2225,40 +3364,246 @@ async function execNodeBuild(entryPath, outfilePath, minify, envFiles, cwd, bunP
 		entryPath
 	], outfilePath, cwd);
 	const output = await readFile(outfilePath, "utf8");
-	await writeFile(outfilePath, "#!/usr/bin/env node\n" + output.replace(/^#![^\n]*(?:\n|$)/, ""));
+	const shebang = `#!/usr/bin/env ${target}\n`;
+	await writeFile(outfilePath, shebang + output.replace(/^#![^\n]*(?:\n|$)/, ""));
 	if (process.platform !== "win32") await chmod(outfilePath, 493);
 }
-async function execDenoBuild(entryPath, outfilePath, target, cwd) {
-	const denoPath = which("deno");
-	if (!denoPath) throw new Error("Deno is required for the deno runtime but was not found on PATH.\n  Install Deno from https://deno.com/ and try again.");
-	await runBuildProcess({
-		command: denoPath,
-		env: { ...process.env }
-	}, createDenoCompileArgs(entryPath, outfilePath, target), outfilePath, cwd);
+async function execDenoBuild(entryPath, outfilePath, target, cwd, runner = resolveDenoBuildRunner()) {
+	await runBuildProcess(runner, createDenoCompileArgs(entryPath, outfilePath, target), outfilePath, cwd);
+}
+/** tsdown's executable target for a Node target, embedding exactly `nodeVersion`. */
+function nodeExeTarget(target, nodeVersion) {
+	const { os, cpu } = NODE_TARGETS.info[target];
+	return {
+		platform: os === "win32" ? "win" : os,
+		arch: cpu,
+		nodeVersion
+	};
 }
 /**
-* Prepare a CLI entry's Command Snapshot in the user's project context.
+* Script the selected Node runs to turn one Bun bundle into one target's
+* executable with tsdown's programmatic `build`. Every value is embedded via
+* JSON.stringify.
+*/
+function createNodeExeBuildScript(options) {
+	return `// Generated by crust build for a Node standalone binary; deleted when the build finishes.
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+const options = ${JSON.stringify(options)};
+const { build } = await import(pathToFileURL(createRequire(options.tsdownPackageJson).resolve("tsdown")).href);
+await build({
+	config: false,
+	cwd: options.cwd,
+	entry: { app: options.entry },
+	outDir: options.bundleDir,
+	format: "esm",
+	platform: "node",
+	dts: false,
+	// Rolldown reprints the Bun bundle, so it minifies again.
+	minify: options.minify,
+	logLevel: "warn",
+	report: false,
+	// Bun already inlined the PUBLIC_* constants; inline nothing from this environment.
+	envPrefix: [],
+	// Bun leaves only Node built-ins as imports; fail on anything else, which
+	// an executable shipping no node_modules could not resolve.
+	deps: { alwaysBundle: () => true, onlyBundle: false, onlyImport: [] },
+	exe: { outDir: options.exeDir, fileName: "app", targets: [options.target] },
+});
+`;
+}
+/**
+* Build a single entry file into a Node standalone executable: Bun first
+* bundles it for Node exactly as a Node runtime package ({@link execNodeBuild}:
+* `PUBLIC_*` constants from `envFiles` and the environment, each module's own
+* `import.meta.main` and `require.main === module`, CommonJS and ESM inputs),
+* then tsdown's executable builder (Node SEA), run by the selected external
+* Node, turns that bundle into an executable embedding exactly its version
+* for `target`. tsdown takes a single entry per executable, so callers build
+* every command separately. Matching official Node binaries for targets are
+* downloaded, checksum-verified, and cached by @tsdown/exe. Builds for darwin
+* are only code-signed on a macOS host.
 *
-* The entry runs as a subprocess with `CRUST_INTERNAL_SNAPSHOT_PATH` pointing
-* to a temporary file. `.execute()` validates and writes the command graph and
-* adjacent Build Report, then exits before any following entrypoint code can run.
+* @param compiler - The selected Node compiler (`resolveNodeBinaryCompiler`)
+* @param bunRunner - The Bun that bundles (`resolveBunBuildRunner`)
+* @param onWarning - Receives the backend's warnings (such as a skipped code
+*   signature) after a successful build
+* @throws {Error} If the build fails
+*/
+async function execNodeBinaryBuild(entryPath, outfilePath, minify, target, envFiles, cwd, compiler, bunRunner, onWarning = () => {}) {
+	const workDir = await mkdtemp(join(tmpdir(), "crust-node-exe-"));
+	try {
+		const scriptPath = join(workDir, "build.mjs");
+		const bunBundle = join(workDir, "app.mjs");
+		const exeDir = join(workDir, "exe");
+		await execNodeBuild(resolve(cwd, entryPath), bunBundle, minify, envFiles, cwd, [], bunRunner);
+		await writeFile(scriptPath, createNodeExeBuildScript({
+			tsdownPackageJson: compiler.backend.packageJsonPath,
+			cwd,
+			entry: bunBundle,
+			bundleDir: join(workDir, "bundle"),
+			exeDir,
+			minify,
+			target: nodeExeTarget(target, compiler.version)
+		}));
+		const { exitCode, stdout, stderr } = await runProcess(compiler.runner.command, [scriptPath], {
+			env: compiler.runner.env,
+			cwd,
+			stdio: "collect"
+		});
+		const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+		if (exitCode !== 0) throw new Error(`Build failed for ${outfilePath}${output ? `:\n${output}` : ""}`);
+		const produced = await readdir(exeDir);
+		if (produced.length !== 1) throw new Error(`Build failed for ${outfilePath}: expected one executable from tsdown, found ${JSON.stringify(produced)}.`);
+		await copyFile(join(exeDir, produced[0]), outfilePath);
+		if (output) onWarning(output);
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true,
+			maxRetries: 3,
+			retryDelay: 100
+		});
+	}
+}
+function createNodeExeProvisionScript(tsdownPackageJson, targets) {
+	return `// Generated by crust build to provision Node binaries for targets; deleted when it exits.
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+const exe = createRequire(realpathSync(${JSON.stringify(tsdownPackageJson)})).resolve("@tsdown/exe");
+const { resolveNodeBinary } = await import(pathToFileURL(exe).href);
+for (const { name, target } of ${JSON.stringify(targets)}) {
+	try {
+		await resolveNodeBinary(target, {});
+	} catch (error) {
+		console.error(name + ": " + error.message + (error.cause?.message ? "\\n" + error.cause.message : ""));
+		process.exit(1);
+	}
+}
+`;
+}
+/**
+* Provisions the Node binary every target embeds before anything is staged,
+* with the selected Node and the call tsdown's executable builder makes per
+* target (@tsdown/exe's `resolveNodeBinary`): an uncached official archive of
+* exactly `compiler.version` is downloaded, checksum-verified, unpacked with
+* the tool that target's archive needs on this host, and cached, where
+* {@link execNodeBinaryBuild} then finds it. A missing unpacking tool, a failed
+* download, or a checksum mismatch therefore fails here, before `.crust/` is
+* replaced; cached targets need nothing.
+*
+* @throws {Error} If a target cannot be provisioned
+*/
+async function provisionNodeExeTargets(targets, cwd, compiler) {
+	const workDir = await mkdtemp(join(tmpdir(), "crust-node-exe-provision-"));
+	try {
+		const scriptPath = join(workDir, "provision.mjs");
+		await writeFile(scriptPath, createNodeExeProvisionScript(compiler.backend.packageJsonPath, targets.map((name) => ({
+			name,
+			target: nodeExeTarget(name, compiler.version)
+		}))));
+		const { exitCode, stdout, stderr } = await runProcess(compiler.runner.command, [scriptPath], {
+			env: compiler.runner.env,
+			cwd,
+			stdio: "collect"
+		});
+		if (exitCode !== 0) {
+			const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+			throw new Error(`Could not provision the Node ${compiler.version} binary that node standalone binaries embed${output ? `:\n${output}` : "."}\n  tsdown downloads each target's official Node archive once and unpacks it with tar (GNU tar also needs xz for linux targets), or unzip for win targets on non-Windows hosts.
+  Install the missing tool, or build only targets this machine can provision (--target).`);
+		}
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Oldest `deno` accepted to bundle a Deno runtime package. Deno 2.4 resolves a
+* package.json project's npm dependencies from the registry instead of its
+* installed node_modules, so it can bundle a different Crust than the project
+* installed. Tested on Linux x64 with Deno 2.5.0 through 2.9.6.
+*/
+const DENO_PACKAGE_MIN_VERSION = "2.5.0";
+/**
+* Select the external deno that bundles a Deno runtime package, reading its
+* version in the project directory `cwd`. Call it before staging is replaced.
+* A runtime package embeds no Deno, so `engines.deno` stays a consumer
+* requirement and is not checked against this bundler.
+*/
+async function resolveDenoPackageBundler(cwd, runner = resolveDenoBuildRunner()) {
+	const version = await readCompilerVersion("deno", runner, cwd);
+	if (!(0, import_satisfies.default)(version, `>=2.5.0`, { includePrerelease: true })) throw new Error(`Deno ${version} (${runner.command}) cannot bundle a Deno runtime package; deno ${DENO_PACKAGE_MIN_VERSION} or newer is required.\n  Older deno bundle resolves package.json dependencies from the npm registry instead of the installed node_modules.
+  crust does not install or upgrade Deno; put a newer deno first on PATH (e.g. with your version manager).`);
+	return {
+		runtime: "deno",
+		runner,
+		version
+	};
+}
+/**
+* Bundle a Deno runtime package entry with native `deno bundle`, which resolves
+* dependencies through the project's own Deno setup (deno.json imports,
+* package.json with its installed node_modules) and inlines them into one file.
 *
-* Runs with the same bun as compilation (`resolveBunBuildRunner`): bun on
-* PATH, or a compiled standalone crust executable as `BUN_BE_BUN=1`, so
-* arbitrary `.ts` entries run without a separate `bun` install.
+* Bundle the declared command directly so Deno preserves its `import.meta.main`
+* semantics without making dependencies main. Prepend the packaged-build marker
+* (`PACKAGED_BUILD_KEY`) to the bundled code so it runs before the inlined
+* application graph. The output has no shebang or permission flags: consumers
+* choose grants with `deno run` / `deno install`.
+* No env files or plugins: `deno bundle` has no PUBLIC_* filter or Bun plugins.
 */
+async function execDenoPackageBuild(entryPath, outfilePath, cwd, runner = resolveDenoBuildRunner()) {
+	await runBuildProcess(runner, [
+		"bundle",
+		"--platform=deno",
+		"--packages=bundle",
+		"--output",
+		outfilePath,
+		resolve(cwd, entryPath)
+	], outfilePath, cwd);
+	const output = await readFile(outfilePath, "utf8");
+	await writeFile(outfilePath, `globalThis[Symbol.for(${JSON.stringify(PACKAGED_BUILD_KEY)})] = true;\n` + output.replace(/^#![^\n]*(?:\n|$)/, ""));
+}
 const SNAPSHOT_TIMEOUT_MS = 3e4;
+const SNAPSHOT_FORWARDED_SIGNALS = [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP",
+	"SIGQUIT"
+];
 function isBuildReport(value) {
 	return isJsonObject(value) && Array.isArray(value.extensions) && value.extensions.every((extension) => isJsonObject(extension) && typeof extension.id === "string" && Array.isArray(extension.files) && extension.files.every((file) => typeof file === "string"));
 }
-async function buildEntrypoint(entryPath, outDir, envFiles, io, cwd) {
+/**
+* Prepare a CLI entry's Command Snapshot in the user's project context.
+*
+* The entry runs as a subprocess with `CRUST_INTERNAL_SNAPSHOT_PATH` pointing
+* to a temporary file. `.execute()` validates and writes the command graph and
+* adjacent Build Report, then exits before any following entrypoint code can run.
+*
+* Runs with the same bun as compilation (`resolveBunBuildRunner`, or the
+* pinned Bun `runner`): bun on PATH, or a compiled standalone crust executable
+* as `BUN_BE_BUN=1`, so arbitrary `.ts` entries run without a separate `bun`
+* install.
+*
+* After `timeoutMs`, the entry's POSIX process group or live Windows process
+* tree is killed and preparation fails, even if a descendant still holds stderr.
+* On POSIX, SIGINT, SIGTERM, SIGHUP, SIGQUIT or a synchronous exit of this
+* process also kills the entry's group, and whatever remains of the group is
+* killed once preparation settles.
+*/
+async function buildEntrypoint(entryPath, outDir, envFiles, io, cwd, runner = resolveBunBuildRunner(), timeoutMs = SNAPSHOT_TIMEOUT_MS) {
 	const absoluteEntry = resolve(entryPath);
 	const snapshotDir = await mkdtemp(join(tmpdir(), "crust-snapshot-"));
 	const snapshotPath = join(snapshotDir, "command.json");
 	const buildReportPath = join(snapshotDir, "build-report.json");
 	try {
-		const runner = resolveBunBuildRunner();
-		const spawnedAt = Date.now();
+		const detached = process.platform !== "win32";
 		const proc = spawn(runner.command, [...toBunEnvFileArgs(envFiles), absoluteEntry], {
 			env: {
 				...runner.env,
@@ -2271,15 +3616,47 @@ async function buildEntrypoint(entryPath, outDir, envFiles, io, cwd) {
 				"ignore",
 				"pipe"
 			],
-			timeout: SNAPSHOT_TIMEOUT_MS
+			detached
 		});
-		const stderrPromise = text(proc.stderr);
-		const [exitCode] = await once(proc, "close");
-		const stderr = (await stderrPromise).trim();
-		if (proc.signalCode !== null) {
-			if (Date.now() - spawnedAt >= SNAPSHOT_TIMEOUT_MS) throw new Error(`Command Snapshot preparation timed out after ${SNAPSHOT_TIMEOUT_MS / 1e3}s.\n  An Extension build hook may be hanging. Use --no-validate to skip entry preparation and build hooks.`);
-			throw new Error(`Command Snapshot preparation was killed by ${proc.signalCode}.${stderr ? `\n${stderr}` : ""}`);
+		let stop;
+		const stopped = new Promise((_, reject) => {
+			stop = (message) => {
+				let failure = new Error(message);
+				try {
+					killProcessTree(proc);
+				} catch (cause) {
+					failure = new Error(`${message}\n  Process-tree cleanup failed.`, { cause });
+				}
+				proc.stderr.destroy();
+				reject(failure);
+			};
+		});
+		const timer = setTimeout(() => stop(`Command Snapshot preparation timed out after ${timeoutMs / 1e3}s.\n  An Extension build hook may be hanging. Use --no-validate to skip entry preparation and build hooks.`), timeoutMs);
+		const onSignal = (signal) => {
+			removeLifetimeListeners();
+			stop(`Command Snapshot preparation was interrupted by ${signal}.`);
+			if (process.listenerCount(signal) === 0) process.kill(process.pid, signal);
+		};
+		const killRemainingGroup = () => {
+			try {
+				killProcessTree(proc);
+			} catch {}
+		};
+		const removeLifetimeListeners = () => {
+			for (const signal of SNAPSHOT_FORWARDED_SIGNALS) process.removeListener(signal, onSignal);
+			process.removeListener("exit", killRemainingGroup);
+		};
+		if (detached) {
+			for (const signal of SNAPSHOT_FORWARDED_SIGNALS) process.prependListener(signal, onSignal);
+			process.on("exit", killRemainingGroup);
 		}
+		const [rawStderr, [exitCode]] = await Promise.race([Promise.all([text(proc.stderr), once(proc, "close")]), stopped]).finally(() => {
+			clearTimeout(timer);
+			removeLifetimeListeners();
+			if (detached) killRemainingGroup();
+		});
+		const stderr = rawStderr.trim();
+		if (proc.signalCode !== null) throw new Error(`Command Snapshot preparation was killed by ${proc.signalCode}.${stderr ? `\n${stderr}` : ""}`);
 		if (exitCode !== 0) throw new Error(stderr || "Command Snapshot preparation failed");
 		if (stderr) {
 			const styled = stderr.split("\n").map((line) => line.startsWith("Warning:") ? `${yellow("Warning:")}${line.slice(8)}` : line).join("\n");
@@ -2335,6 +3712,12 @@ async function buildEntrypoint(entryPath, outDir, envFiles, io, cwd) {
 //#region src/utils/distribute.ts
 /** Project-relative directory that `crust build` owns: wiped per build, read by `crust publish`. */
 const CRUST_DIR = ".crust";
+/**
+* What one build distributes: a runtime `package` (a root-only JavaScript
+* bundle that needs the runtime installed) or standalone `binary` executables
+* in platform packages behind a Node launcher.
+*/
+const ARTIFACT_KINDS = ["package", "binary"];
 const MAX_PACKAGE_NAME_LENGTH = 214;
 const METADATA_KEYS = [
 	"description",
@@ -2633,9 +4016,10 @@ function copyLicense(cwd, packageDirs) {
 	const licensePath = join(cwd, licenseName);
 	for (const packageDir of packageDirs) copyFileSync(licensePath, join(packageDir, licenseName));
 }
-function writeDistributionManifest(stageDir, metadata, commands, targets, build) {
+function writeDistributionManifest(stageDir, metadata, identity, commands, targets, build) {
 	const manifest = {
 		version: metadata.version,
+		...identity,
 		root: {
 			name: metadata.rootPackageName,
 			dir: "root",
@@ -2656,7 +4040,17 @@ function writeDistributionManifest(stageDir, metadata, commands, targets, build)
 	writeJson(join(stageDir, "manifest.json"), manifest);
 	return manifest;
 }
-function stageDistributionPackages(cwd, stageDir, metadata, commands, targets, options) {
+/** `pkg` without `engines.node`, dropping `engines` once nothing else is left. */
+function omitNodeEngine(pkg) {
+	const { engines, ...rest } = pkg;
+	if (engines?.node === void 0) return pkg;
+	const others = Object.entries(engines).filter(([runtime]) => runtime !== "node");
+	return others.length > 0 ? {
+		...rest,
+		engines: Object.fromEntries(others)
+	} : rest;
+}
+function stageDistributionPackages(cwd, stageDir, metadata, platformMetadata, commands, targets, options) {
 	const rootDir = join(stageDir, "root");
 	const rootBinDir = join(rootDir, "bin");
 	mkdirSync(rootBinDir, { recursive: true });
@@ -2664,7 +4058,7 @@ function stageDistributionPackages(cwd, stageDir, metadata, commands, targets, o
 	copyRootReadme(cwd, rootDir);
 	for (const target of targets) {
 		mkdirSync(join(target.packageDir, "bin"), { recursive: true });
-		writeJson(join(target.packageDir, "package.json"), buildDistributionPlatformPackageJson(metadata, commands, target));
+		writeJson(join(target.packageDir, "package.json"), buildDistributionPlatformPackageJson(platformMetadata, commands, target));
 	}
 	copyLicense(cwd, [rootDir, ...targets.map((target) => target.packageDir)]);
 }
@@ -2674,15 +4068,20 @@ function stageDistributionPackages(cwd, stageDir, metadata, commands, targets, o
 * Returns every generated package.json, launcher, and compiled command in staging order.
 */
 async function runDistributeBuild(plan, distribution, io, build) {
-	const metadata = resolveDistributionMetadata(plan.cwd, plan.userPackageJson);
+	const sourceMetadata = resolveDistributionMetadata(plan.cwd, plan.userPackageJson);
 	const commands = plan.entries.map((entry) => entry.command);
 	const table = distribution.table;
+	const platformMetadata = plan.runtime === "node" && table ? {
+		...sourceMetadata,
+		rootPackageJson: omitNodeEngine(sourceMetadata.rootPackageJson)
+	} : sourceMetadata;
+	const metadata = sourceMetadata.exports === void 0 ? platformMetadata : sourceMetadata;
 	const distributionTargets = table ? distribution.targets.map((target) => resolveDistributionTarget(table, plan.stageDir, metadata.rootPackageName, target)) : [];
 	io.stdout(table ? `Staging ${bold(`${distributionTargets.length}`)} distribution target(s) in ${dim(plan.stageDir)}...` : `Staging a root-only npm package in ${dim(plan.stageDir)}...`);
 	const artifactOutDir = plan.validate ? plan.outDir : void 0;
 	const artifacts = collectArtifacts(artifactOutDir);
 	const includeDirs = collectIncludeDirs(plan.cwd, plan.stageDir, plan.include, artifacts.names);
-	stageDistributionPackages(plan.cwd, plan.stageDir, metadata, commands, distributionTargets, {
+	stageDistributionPackages(plan.cwd, plan.stageDir, metadata, platformMetadata, commands, distributionTargets, {
 		artifactDirs: [...artifacts.names, ...includeDirs],
 		manPages: artifacts.manPages
 	});
@@ -2746,7 +4145,14 @@ async function runDistributeBuild(plan, distribution, io, build) {
 			command
 		});
 	}
-	writeDistributionManifest(plan.stageDir, metadata, commands, distributionTargets, build);
+	writeDistributionManifest(plan.stageDir, metadata, table ? {
+		runtime: plan.runtime,
+		artifact: "binary",
+		embeddedRuntimeVersion: distribution.embeddedRuntimeVersion
+	} : {
+		runtime: plan.runtime,
+		artifact: "package"
+	}, commands, distributionTargets, build);
 	const manifestPath = join(plan.stageDir, "manifest.json");
 	io.stdout(`\n${green("✓")} Staged ${bold(`${distributionTargets.length + 1}`)} npm package(s) successfully:`);
 	io.stdout(`  ${rootDir}`);
@@ -2768,9 +4174,13 @@ function collectIncludeDirs(cwd, stageDir, include, artifactNames) {
 		if (!existsSync(dir) || !statSync(dir).isDirectory()) throw new Error(`package.json crust.include entry ${JSON.stringify(entry)} is not a directory: ${dir}`);
 		assertResolvesInsideProject(cwd, entry, dir);
 		if (isWithin(stageDir, dir) || isWithin(dir, stageDir)) throw new Error(`package.json crust.include entry ${JSON.stringify(entry)} overlaps the build output directory ${stageDir}, which crust build replaces.`);
-		if (name.split(sep)[0] === "bin") throw new Error(`package.json crust.include entry ${JSON.stringify(entry)} conflicts with the generated npm bin directory.\n  Include a directory with a different top-level name.`);
+		if (name.toLowerCase().split(sep)[0] === "bin") throw new Error(`package.json crust.include entry ${JSON.stringify(entry)} conflicts with the generated npm bin directory.\n  Include a directory with a different top-level name.`);
 		const posixName = name.replaceAll(sep, "/");
-		const overlap = names.find((staged) => staged === posixName || staged.startsWith(`${posixName}/`) || posixName.startsWith(`${staged}/`));
+		const key = posixName.toLowerCase();
+		const overlap = names.find((staged) => {
+			const stagedKey = staged.toLowerCase();
+			return stagedKey === key || stagedKey.startsWith(`${key}/`) || key.startsWith(`${stagedKey}/`);
+		});
 		if (overlap !== void 0) throw new Error(`package.json crust.include entry ${JSON.stringify(entry)} overlaps "${overlap}", which is already staged (duplicate include or Extension artifact directory).`);
 		names.push(posixName);
 		includeDirs.push(posixName);
@@ -2837,7 +4247,8 @@ function collectArtifacts(artifactOutDir) {
 		manPages: []
 	};
 	const names = readdirSync(artifactOutDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-	if (names.includes("bin")) throw new Error(`Artifact directory "bin" in ${artifactOutDir} conflicts with the generated npm bin directory.\n  Emit build artifacts under a different top-level name.`);
+	const binName = names.find((name) => name.toLowerCase() === "bin");
+	if (binName !== void 0) throw new Error(`Artifact directory "${binName}" in ${artifactOutDir} conflicts with the generated npm bin directory.\n  Emit build artifacts under a different top-level name.`);
 	return {
 		names,
 		manPages: names.includes("man") ? readdirSync(join(artifactOutDir, "man"), { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort() : []
@@ -2848,6 +4259,7 @@ function collectArtifacts(artifactOutDir) {
 /** Also mirrored by `schema/package.json`; build.test.ts guards against drift. */
 const CRUST_CONFIG_KEYS = [
 	"runtime",
+	"artifact",
 	"targets",
 	"bunPlugins",
 	"include"
@@ -2855,6 +4267,9 @@ const CRUST_CONFIG_KEYS = [
 function isBuildRuntime(value) {
 	return typeof value === "string" && BUILD_RUNTIMES.some((runtime) => runtime === value);
 }
+function isArtifactKind(value) {
+	return typeof value === "string" && ARTIFACT_KINDS.some((kind) => kind === value);
+}
 function isString(value) {
 	return typeof value === "string";
 }
@@ -2873,6 +4288,10 @@ function readCrustConfig(pkg) {
 		if (!isBuildRuntime(crust.runtime)) throw new Error(`Invalid package.json crust.runtime ${JSON.stringify(crust.runtime)}. Valid runtimes: ${BUILD_RUNTIMES.join(", ")}`);
 		config.runtime = crust.runtime;
 	}
+	if (crust.artifact !== void 0) {
+		if (!isArtifactKind(crust.artifact)) throw new Error(`Invalid package.json crust.artifact ${JSON.stringify(crust.artifact)}. Valid artifacts: ${ARTIFACT_KINDS.join(", ")}`);
+		config.artifact = crust.artifact;
+	}
 	if (crust.targets !== void 0) {
 		if (!isStringArray(crust.targets) || crust.targets.length === 0) throw new Error("package.json crust.targets must be a non-empty array of canonical compiler targets, e.g. [\"bun-linux-x64\", \"bun-darwin-arm64\"].");
 		config.targets = crust.targets;
@@ -2997,19 +4416,44 @@ function resolveBinEntries(cwd, pkg) {
 		};
 	});
 }
+/** What earlier releases built for each runtime without being asked; quoted in the migration error. */
+const IMPLICIT_ARTIFACTS = {
+	bun: "binary",
+	deno: "binary",
+	node: "package"
+};
+/** `option` (the `artifact` build option or `--artifact`) > package.json `crust.artifact`; no default. */
+function resolveArtifact(option, config, runtime) {
+	if (option !== void 0 && !isArtifactKind(option)) throw new Error(`Invalid artifact ${JSON.stringify(option)}. Valid artifacts: ${ARTIFACT_KINDS.join(", ")}`);
+	const artifact = option ?? config.artifact;
+	if (artifact === void 0) {
+		const previous = IMPLICIT_ARTIFACTS[runtime];
+		throw new Error(`crust build needs an artifact kind: pass --artifact package|binary or set package.json "crust": { "artifact": "package" | "binary" }.
+  package: one JavaScript bundle per command that runs on the consumer's installed runtime.
+  binary: standalone executables in per-platform npm packages behind a Node launcher.
+  Earlier versions built a ${previous} for the ${runtime} runtime implicitly; set "artifact": "${previous}" to keep that output.`);
+	}
+	return {
+		runtime,
+		artifact
+	};
+}
 function planBuild(options, cwd) {
 	const userPackageJson = readUserPackageJson(cwd);
 	const config = readCrustConfig(userPackageJson);
 	const { runtime, source: runtimeSource } = resolveBuildRuntime(userPackageJson, config, cwd);
+	const selection = resolveArtifact(options.artifact, config, runtime);
 	const entries = resolveBinEntries(cwd, userPackageJson);
 	validatePackageIdentity(userPackageJson, "package.json");
 	const envFiles = resolveEnvFilePaths(cwd, options.envFiles);
 	const bunPlugins = config.bunPlugins ?? [];
-	if (runtime === "node" && options.targets?.length) throw new Error("--target cannot be used with the node runtime.\n  Node builds produce one portable JavaScript artifact.");
-	if (runtime === "node" && config.targets !== void 0) throw new Error("package.json crust.targets is not supported with the node runtime.\n  Node builds produce one portable JavaScript artifact; remove crust.targets or set crust.runtime to bun or deno.");
-	if (runtime === "deno" && options.minify) throw new Error("--minify is not supported with the deno runtime.\n  deno compile has no minification step; drop the flag.");
-	if (runtime === "deno" && envFiles.length > 0) throw new Error("--env-file is not supported with the deno runtime.\n  deno compile embeds every variable from the file into the binary — secrets included —\n  with no PUBLIC_* filter. Load configuration at runtime instead (e.g. deno run --env-file).");
-	if (runtime === "deno" && bunPlugins.length > 0) throw new Error("package.json crust.bunPlugins is not supported with the deno runtime.\n  deno compile has no Bun bundler; remove crust.bunPlugins or set crust.runtime to bun.");
+	if (selection.artifact === "package" && options.targets?.length) throw new Error("--target cannot be used with runtime packages (artifact package).\n  A runtime package is one portable JavaScript bundle; drop --target or use artifact binary.");
+	if (selection.artifact === "package" && config.targets !== void 0) throw new Error("package.json crust.targets is not supported for runtime packages (artifact package).\n  A runtime package is one portable JavaScript bundle; remove crust.targets or set \"artifact\": \"binary\".");
+	const denoTool = selection.artifact === "binary" ? "deno compile" : "deno bundle";
+	if (runtime === "deno" && options.minify) throw new Error(selection.artifact === "binary" ? "--minify is not supported with the deno runtime.\n  deno compile has no minification step; drop the flag." : "--minify is not supported with the deno runtime.\n  crust does not minify Deno runtime packages; drop the flag.");
+	if (runtime === "deno" && envFiles.length > 0) throw new Error(selection.artifact === "binary" ? "--env-file is not supported with the deno runtime.\n  deno compile embeds every variable from the file into the binary — secrets included —\n  with no PUBLIC_* filter. Load configuration at runtime instead (e.g. deno run --env-file)." : "--env-file is not supported with the deno runtime.\n  deno bundle has no PUBLIC_* build-time constants. Load configuration at runtime instead (e.g. deno run --env-file).");
+	if (runtime === "deno" && bunPlugins.length > 0) throw new Error(`package.json crust.bunPlugins is not supported with the deno runtime.\n  ${denoTool} has no Bun bundler; remove crust.bunPlugins or set crust.runtime to bun.`);
+	if (runtime === "node" && selection.artifact === "binary" && bunPlugins.length > 0) throw new Error("package.json crust.bunPlugins is not supported for node standalone binaries.\n  Remove crust.bunPlugins, or use artifact package or the bun runtime.");
 	const stageDir = resolve(cwd, CRUST_DIR);
 	const common = {
 		cwd,
@@ -3024,39 +4468,102 @@ function planBuild(options, cwd) {
 		validate: options.validate ?? true,
 		minify: runtime === "deno" ? false : options.minify ?? true
 	};
-	if (runtime === "node") return {
+	if (selection.artifact === "package") return {
 		...common,
-		runtime
+		runtime: selection.runtime,
+		artifact: selection.artifact
 	};
 	const targetInputs = options.targets?.length ? options.targets : config.targets;
-	if (runtime === "bun") {
-		const targets = resolveTargets(BUN_TARGETS, targetInputs);
-		assertTargetsBuildableWithoutBun(targets);
-		return {
-			...common,
-			runtime,
-			targets
-		};
-	}
+	const { runtime: binaryRuntime, artifact } = selection;
+	if (binaryRuntime === "bun") return {
+		...common,
+		runtime: binaryRuntime,
+		artifact,
+		targets: resolveTargets(BUN_TARGETS, targetInputs)
+	};
+	if (binaryRuntime === "node") return {
+		...common,
+		runtime: binaryRuntime,
+		artifact,
+		targets: resolveTargets(NODE_TARGETS, targetInputs)
+	};
 	return {
 		...common,
-		runtime,
+		runtime: binaryRuntime,
+		artifact,
 		targets: resolveTargets(DENO_TARGETS, targetInputs)
 	};
 }
-/** Bun and Deno stage platform packages behind a Node launcher; Node stages a root-only bundle. */
-async function runStagedBuild(plan, io, reports) {
-	if (plan.runtime === "bun") return runDistributeBuild(plan, {
-		table: BUN_TARGETS,
-		targets: plan.targets,
-		execute: (entry, outfile, target) => execBuild(entry, outfile, plan.minify, target, plan.envFiles, plan.cwd, plan.bunPlugins)
-	}, io, reports);
-	if (plan.runtime === "deno") return runDistributeBuild(plan, {
+/**
+* Selects every compiler the build uses, once, before `.crust/` is wiped, so a
+* missing tool or an engines mismatch keeps the previous stage. Binaries use
+* the selected compiler's own version (`resolveBinaryCompiler`, or
+* `resolveNodeBinaryCompiler` with tsdown's requirements for node, whose
+* targets' embedded Node binaries are also provisioned here); runtime
+* packages are bundled by Bun (or, for Deno, by `deno bundle`) and embed no
+* runtime, so engines stay a consumer requirement there and are not checked
+* against the bundler.
+*/
+async function selectCompilers(plan, io) {
+	if (plan.artifact === "package" && plan.runtime === "deno") {
+		const bundler = await resolveDenoPackageBundler(plan.cwd);
+		io.stdout(`${dim("Compiler:")} deno ${bundler.version} ${dim(`(${bundler.runner.command}, deno bundle)`)}`);
+		io.stderr("Deno runtime packages are experimental: they are bundled with deno bundle, which Deno marks experimental.");
+		return {
+			snapshotRunner: plan.validate ? resolveBunBuildRunner() : void 0,
+			stage: (reports) => runDistributeBuild(plan, { execute: (entry, outfile) => execDenoPackageBuild(entry, outfile, plan.cwd, bundler.runner) }, io, reports)
+		};
+	}
+	if (plan.artifact === "package") {
+		const runner = resolveBunBuildRunner();
+		const bundle = plan.runtime === "bun" ? execBunPackageBuild : execNodeBuild;
+		return {
+			snapshotRunner: runner,
+			stage: (reports) => runDistributeBuild(plan, { execute: (entry, outfile) => bundle(entry, outfile, plan.minify, plan.envFiles, plan.cwd, plan.bunPlugins, runner) }, io, reports)
+		};
+	}
+	const printCompiler = (compiler) => io.stdout(`${dim("Compiler:")} ${compiler.runtime} ${compiler.version} ${dim(`(${compiler.runner.command})`)}`);
+	if (plan.runtime === "node") {
+		const compiler = await resolveNodeBinaryCompiler(plan.userPackageJson, plan.cwd);
+		printCompiler(compiler);
+		await provisionNodeExeTargets(plan.targets, plan.cwd, compiler);
+		const bunRunner = resolveBunBuildRunner();
+		const distribution = {
+			table: NODE_TARGETS,
+			targets: plan.targets,
+			embeddedRuntimeVersion: compiler.version,
+			execute: (entry, outfile, target) => execNodeBinaryBuild(entry, outfile, plan.minify, target, plan.envFiles, plan.cwd, compiler, bunRunner, io.stderr)
+		};
+		return {
+			snapshotRunner: bunRunner,
+			stage: (reports) => runDistributeBuild(plan, distribution, io, reports)
+		};
+	}
+	const compiler = await resolveBinaryCompiler(plan.runtime, plan.userPackageJson, plan.cwd);
+	printCompiler(compiler);
+	if (plan.runtime === "bun") {
+		assertTargetsBuildableWithoutBun(plan.targets, void 0, compiler.runner);
+		const distribution = {
+			table: BUN_TARGETS,
+			targets: plan.targets,
+			embeddedRuntimeVersion: compiler.version,
+			execute: (entry, outfile, target) => execBuild(entry, outfile, plan.minify, target, plan.envFiles, plan.cwd, plan.bunPlugins, compiler.runner)
+		};
+		return {
+			snapshotRunner: compiler.runner,
+			stage: (reports) => runDistributeBuild(plan, distribution, io, reports)
+		};
+	}
+	const distribution = {
 		table: DENO_TARGETS,
 		targets: plan.targets,
-		execute: (entry, outfile, target) => execDenoBuild(entry, outfile, target, plan.cwd)
-	}, io, reports);
-	return runDistributeBuild(plan, { execute: (entry, outfile) => execNodeBuild(entry, outfile, plan.minify, plan.envFiles, plan.cwd, plan.bunPlugins) }, io, reports);
+		embeddedRuntimeVersion: compiler.version,
+		execute: (entry, outfile, target) => execDenoBuild(entry, outfile, target, plan.cwd, compiler.runner)
+	};
+	return {
+		snapshotRunner: plan.validate ? resolveBunBuildRunner() : void 0,
+		stage: (reports) => runDistributeBuild(plan, distribution, io, reports)
+	};
 }
 /**
 * Prepares every entry's Command Snapshot and checks that its root command is
@@ -3065,13 +4572,13 @@ async function runStagedBuild(plan, io, reports) {
 * the merge fails on any path two entries both write. Returns each command's
 * Build Report.
 */
-async function prepareEntries(plan, io) {
+async function prepareEntries(plan, io, runner) {
 	const owners = /* @__PURE__ */ new Map();
 	const reports = {};
 	for (const { command, entryPath } of plan.entries) {
 		const entryOutDir = await mkdtemp(join(tmpdir(), "crust-artifacts-"));
 		try {
-			const { snapshot, build: report } = await buildEntrypoint(entryPath, entryOutDir, plan.envFiles, io, plan.cwd);
+			const { snapshot, build: report } = await buildEntrypoint(entryPath, entryOutDir, plan.envFiles, io, plan.cwd, runner);
 			if (snapshot.meta.name !== command) throw new Error(`package.json bin ${JSON.stringify(command)} builds ${entryPath}, whose root command is named ${JSON.stringify(snapshot.meta.name)}.\n  The installed command, help, man pages, and skills use the root command name, so new Crust(name) must match the bin key; rename one of them.`);
 			printBuildReport(command, report, io.stdout);
 			mergeEntryArtifacts(entryOutDir, plan.outDir, command, owners);
@@ -3085,27 +4592,36 @@ async function prepareEntries(plan, io) {
 	}
 	return reports;
 }
-const activeBuilds = /* @__PURE__ */ new Set();
 /**
-* Stages the publishable npm tree in `<cwd>/.crust`: a root package with one
-* `bin/<command>.js` per package.json `bin` entry, each a Node launcher (Bun,
-* Deno) or the bundle itself (Node), plus one platform package per target for
-* Bun and Deno holding one binary per command. Command names and source
-* entries come from `bin`; the runtime, Bun plugins, and extra directories
-* from package.json `crust`. Compilation and Command Snapshots run in bun
+* Stages the publishable npm tree in `<cwd>/.crust` for one runtime/artifact
+* combination: a root package with one `bin/<command>.js` per package.json
+* `bin` entry, each the command's bundle (artifact `package`) or a Node
+* launcher (artifact `binary`), plus for binaries one platform package per
+* target holding one executable per command. Command names and source entries
+* come from `bin`; the runtime, artifact, Bun plugins, and extra directories
+* from package.json `crust`. Bundling and Command Snapshots run in bun
 * subprocesses (bun on PATH, or the running Bun executable), so this works
-* under Node as well when Bun is installed.
+* under Node as well when Bun is installed; Deno binaries and Deno runtime
+* packages (experimental, deno 2.5.0 or newer) need deno on PATH, and Node
+* binaries a node on PATH that Crust's tsdown can build executables with.
 *
-* Throws on any failure. Planning failures (bad options or package.json) leave
-* the previous `.crust/` stage untouched; failures after planning leave a
-* wiped stage without a completion `manifest.json`. Overlapping calls for the
-* same real project directory in this process are rejected before staging.
+* Throws on any failure. Planning and compiler-selection failures (bad
+* options or package.json, a missing or hung compiler, an engines mismatch) leave the
+* previous `.crust/` stage untouched; later failures leave a wiped stage
+* without a completion `manifest.json`. Overlapping calls for the same real
+* project directory are rejected across processes before staging. An interrupted
+* process may leave `.crust.lock`; remove it only when no build is running.
 */
 async function build(options = {}) {
 	const cwd = resolve(options.cwd ?? process.cwd());
 	const project = realpathSync(cwd);
-	if (activeBuilds.has(project)) throw new Error(`crust build is already building ${project}`);
-	activeBuilds.add(project);
+	const lockDir = join(project, `${CRUST_DIR}.lock`);
+	try {
+		mkdirSync(lockDir);
+	} catch (error) {
+		if (!isErrnoException(error) || error.code !== "EEXIST") throw error;
+		throw new Error(`crust build is already building ${project}, or an interrupted build left its lock.\n  Remove ${lockDir} only after confirming no build is running.`, { cause: error });
+	}
 	try {
 		const onLog = options.onLog ?? (() => {});
 		const io = {
@@ -3114,50 +4630,22 @@ async function build(options = {}) {
 		};
 		const plan = planBuild(options, cwd);
 		io.stdout(`${dim("Runtime:")} ${plan.runtime} ${dim(`(${plan.runtimeSource})`)}`);
+		io.stdout(`${dim("Artifact:")} ${plan.artifact}`);
+		const compilers = await selectCompilers(plan, io);
 		rmSync(plan.stageDir, {
 			recursive: true,
 			force: true
 		});
-		const reports = plan.validate ? await prepareEntries(plan, io) : void 0;
-		const artifacts = await runStagedBuild(plan, io, reports);
+		const reports = plan.validate ? await prepareEntries(plan, io, compilers.snapshotRunner) : void 0;
+		const artifacts = await compilers.stage(reports);
 		return {
 			stageDir: plan.stageDir,
 			artifacts,
 			...reports ? { reports } : {}
 		};
 	} finally {
-		activeBuilds.delete(project);
+		rmdirSync(lockDir);
 	}
 }
-defineCommand("build", { description: "Build your CLI for Bun, Deno, or Node" }, (command) => command.flags({
-	name: "target",
-	type: "string",
-	multiple: true,
-	description: `Canonical compiler target(s), or "${HOST_TARGET}" for this machine; repeatable. Omit to stage package.json crust.targets, or every Bun/Deno target`,
-	short: "t"
-}, {
-	name: "env-file",
-	type: "string",
-	multiple: true,
-	description: "Explicit env file(s) used for build-time constants; repeatable"
-}, {
-	name: "validate",
-	type: "boolean",
-	description: "Materialize command definitions before compiling; --no-validate also skips Extension build hooks",
-	default: true
-}, {
-	name: "minify",
-	type: "boolean",
-	description: "Minify the output (default for bun and node; unsupported for deno)"
-}).action(async ({ flags, stdout, stderr }) => {
-	await build({
-		cwd: process.cwd(),
-		targets: flags.target,
-		envFiles: flags["env-file"],
-		minify: flags.minify,
-		validate: flags.validate,
-		onLog: (line, stream) => (stream === "stderr" ? stderr : stdout)(line)
-	});
-}));
 //#endregion
 export { build };