@ariestools/toolchain 8.6.11

package/dist/bin/run-or-exec.mjs

@@ -0,0 +1,975 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import fs, { readFileSync } from "node:fs";
+import process$1 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = 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(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process$1;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (process$1.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const styles = Object.create(null);
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$3 = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs$3.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$3.statSync(path), path, options);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$2 = __require("fs");
+	function isexe(path, options, cb) {
+		fs$2.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$2.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path$2 = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) if (opt.all) found.push(p + ext);
+				else return resolve(p + ext);
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
+					else return cur;
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path$1.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path$1.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$1 = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs$1.openSync(command, "r");
+			fs$1.readSync(fd, buffer, 0, size, 0);
+			fs$1.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+//#region src/lib/crossSpawn.ts
+var import_cross_spawn = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+})))(), 1);
+function spawnSync(command, args, options) {
+	return import_cross_spawn.default.sync(command, args, options);
+}
+//#endregion
+//#region src/lib/packageManagerRuntime.ts
+const DISPLAY_NAMES = {
+	bun: "Bun",
+	npm: "npm",
+	pnpm: "pnpm",
+	yarn: "Yarn"
+};
+const MAC_INSTALL_COMMANDS = {
+	bun: "brew install oven-sh/bun/bun",
+	npm: "brew install node",
+	pnpm: "brew install pnpm",
+	yarn: "brew install yarn"
+};
+const SUPPORTED_PLATFORMS = [
+	"darwin",
+	"linux",
+	"win32"
+];
+function currentPlatform() {
+	return SUPPORTED_PLATFORMS.find((platform) => platform === process.platform) ?? "unknown";
+}
+function shouldAskYesNo(question) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+	process.stdout.write(question);
+	const buffer = Buffer.alloc(1024);
+	const bytesRead = fs.readSync(process.stdin.fd, buffer, 0, buffer.length, null);
+	const answer = buffer.toString("utf8", 0, bytesRead).trim().toLowerCase();
+	return answer === "y" || answer === "yes";
+}
+function isCommandInstalled(command) {
+	const result = spawnSync(command, ["--version"], {
+		encoding: "utf8",
+		stdio: "ignore"
+	});
+	return !result.error && result.status === 0;
+}
+function isPackageManagerInstalled(pm) {
+	return isCommandInstalled(pm);
+}
+function getPackageManagerInstallPlan(pm, platform = currentPlatform()) {
+	const displayName = DISPLAY_NAMES[pm];
+	if (platform === "darwin") {
+		const command = MAC_INSTALL_COMMANDS[pm];
+		return {
+			command,
+			manualInstructions: [`Install ${displayName} with: ${command}`],
+			packageManager: pm,
+			platform,
+			supported: true
+		};
+	}
+	if (platform === "linux") return {
+		manualInstructions: [`Automatic installation for ${displayName} is not implemented on Linux yet.`, `Install ${displayName} manually and re-run the command.`],
+		packageManager: pm,
+		platform,
+		supported: false
+	};
+	if (platform === "win32") return {
+		manualInstructions: [`Automatic installation for ${displayName} is not implemented on Windows yet.`, `Install ${displayName} manually and re-run the command.`],
+		packageManager: pm,
+		platform,
+		supported: false
+	};
+	return {
+		manualInstructions: [`Automatic installation for ${displayName} is not implemented on ${platform} yet.`, `Install ${displayName} manually and re-run the command.`],
+		packageManager: pm,
+		platform,
+		supported: false
+	};
+}
+function printManualInstructions(plan, context) {
+	console.error(chalk.yellow(`${DISPLAY_NAMES[plan.packageManager]} is required for "${context.operation}".`));
+	for (const line of plan.manualInstructions) console.error(chalk.gray(`  ${line}`));
+}
+function shouldInstallWithHomebrew(pm, cwd) {
+	const command = MAC_INSTALL_COMMANDS[pm];
+	return spawnSync("brew", command.replace("brew ", "").split(" "), {
+		cwd,
+		encoding: "utf8",
+		stdio: "inherit"
+	}).status === 0;
+}
+function didEnsurePackageManagerInstalled(pm, context) {
+	if (isPackageManagerInstalled(pm)) return true;
+	const plan = getPackageManagerInstallPlan(pm, context.platform ?? currentPlatform());
+	const displayName = DISPLAY_NAMES[pm];
+	console.error(chalk.yellow(`${context.operation} requires ${displayName}, but it is not installed.`));
+	if (!plan.supported) {
+		printManualInstructions(plan, context);
+		return false;
+	}
+	if (!isCommandInstalled("brew")) {
+		console.error(chalk.yellow("Homebrew is not installed, so automatic installation is unavailable."));
+		console.error(chalk.gray("  Install Homebrew from https://brew.sh and then run:"));
+		console.error(chalk.gray(`  ${plan.command}`));
+		return false;
+	}
+	if (!shouldAskYesNo(chalk.cyan(`Install ${displayName} with Homebrew now? [y/N] `))) {
+		console.error(chalk.gray(`Skipping install. Run "${plan.command}" manually and then retry.`));
+		return false;
+	}
+	console.error(chalk.cyan(`Installing ${displayName} via Homebrew...\n`));
+	if (!shouldInstallWithHomebrew(pm, context.cwd)) {
+		console.error(chalk.red(`Homebrew failed to install ${displayName}.`));
+		console.error(chalk.gray(`Run "${plan.command}" manually and then retry.`));
+		return false;
+	}
+	if (!isPackageManagerInstalled(pm)) {
+		console.error(chalk.red(`${displayName} still does not appear to be installed after Homebrew completed.`));
+		console.error(chalk.gray(`Run "${plan.command}" manually and then retry.`));
+		return false;
+	}
+	console.error(chalk.green(`${displayName} installed successfully.`));
+	return true;
+}
+//#endregion
+//#region src/bin/run-or-exec.ts
+const [script, ...args] = process.argv.slice(2);
+if (!script) {
+	console.error("Usage: run-or-exec <script> [args...]");
+	process.exit(1);
+}
+let hasLocalScript = false;
+try {
+	const scripts = JSON.parse(readFileSync("./package.json", "utf8")).scripts;
+	hasLocalScript = scripts !== void 0 && Object.hasOwn(scripts, script);
+} catch {}
+const result = hasLocalScript ? (() => {
+	if (script === "package-compile" && args.includes("--validate-only")) return spawnSync(script, args, { stdio: "inherit" });
+	if (!didEnsurePackageManagerInstalled("pnpm", { operation: `Run "${script}" via pnpm run-or-exec` })) return { status: 1 };
+	const scriptArgs = script === "package-compile" ? args.filter((arg) => arg !== "--emit-only") : args;
+	return spawnSync("pnpm", [
+		"run",
+		script,
+		"--",
+		...scriptArgs
+	], { stdio: "inherit" });
+})() : spawnSync(script, args, { stdio: "inherit" });
+process.exit(result.status ?? 1);
+//#endregion
+export {};
+
+//# sourceMappingURL=run-or-exec.mjs.map