runset 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,31 +1,107 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { WriteStream } from "node:tty";
-import fs from "node:fs";
-import { inspect, styleText } from "node:util";
 import os from "node:os";
+import { inspect, styleText } from "node:util";
 import cp from "node:child_process";
-//#region src/types.ts
+//#region src/config/std.ts
+const TIMINGS = /* @__PURE__ */ new Set(["realtime", "grouped"]);
+/**
+* Parses `<timing>+<destination>` (either order, either optional) into the
+* axes it names. Unnamed axes are left out so settings can be layered.
+*/
+function parsePartialStd(value) {
+	const result = {};
+	for (const part of value.split("+")) {
+		const token = part.trim();
+		if (token === "") continue;
+		if (TIMINGS.has(token)) result.timing = token;
+		else result.destination = token;
+	}
+	return result;
+}
+function toPartialStd(value) {
+	return typeof value === "string" ? parsePartialStd(value) : value;
+}
+/** Layers a stream setting, in either form, over `base` one axis at a time. */
+function mergeStd(base, value) {
+	return value === void 0 ? base : {
+		...base,
+		...toPartialStd(value)
+	};
+}
+function defaultStd(destination) {
+	return {
+		destination,
+		timing: "realtime"
+	};
+}
+/**
+* Layers bags' stream settings over `base`, later bags over earlier, one axis
+* at a time. `output` names both streams; a stream's own setting in the same
+* bag outranks it.
+*/
+function layerStreams(base, bags) {
+	const result = { ...base };
+	for (const bag of bags) for (const key of ["stderr", "stdout"]) result[key] = mergeStd(mergeStd(result[key], bag.output), bag[key]);
+	return result;
+}
+//#endregion
+//#region src/utils/object.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/config/validate.ts
 const EXIT_ACTIONS = /* @__PURE__ */ new Set([
 	"continue",
 	"restart",
 	"stop"
 ]);
-/** True for an object written without a `command` — a settings entry. */
-function isCommandSettings(definition) {
-	return !("command" in definition);
+function formatValue(value) {
+	return typeof value === "string" ? `"${value}"` : String(value);
 }
-function isStreamDestination(destination) {
-	return destination === "stdout" || destination === "stderr";
+function numberError(name, value, minimum) {
+	if (typeof value !== "number" || Number.isNaN(value) || value < minimum) return `${name} must be a number of ${minimum} or more, got ${formatValue(value)}.`;
+}
+function booleanError(name, value) {
+	return typeof value === "boolean" ? void 0 : `${name} must be true or false, got ${formatValue(value)}.`;
+}
+function stringError(name, value) {
+	return typeof value === "string" ? void 0 : `${name} must be a string, got ${formatValue(value)}.`;
+}
+function envError(name, value) {
+	if (!isPlainObject(value)) return `${name} must be an object.`;
+	const bad = Object.entries(value).find(([, entry]) => typeof entry !== "string");
+	return bad === void 0 ? void 0 : `${name}.${bad[0]} must be a string, got ${formatValue(bad[1])}.`;
+}
+function oneOfError(name, value, allowed) {
+	return allowed.has(value) ? void 0 : `${name} is one of ${[...allowed].join(", ")}, got ${formatValue(value)}.`;
+}
+function actionError(name, value) {
+	return oneOfError(name, value, EXIT_ACTIONS);
+}
+function stdError(name, value) {
+	if (typeof value !== "object" || value === null) return `${name} must be a stream setting.`;
+	if (!TIMINGS.has(value.timing)) return `Invalid timing ${formatValue(value.timing)} for ${name}; one of ${[...TIMINGS].join(", ")}.`;
+	if (typeof value.destination !== "string" || value.destination === "") return `${name} needs a destination to write to.`;
+}
+/** Throws `message` as an `ErrorClass`, if there is one. */
+function check(message, ErrorClass) {
+	if (message !== void 0) throw new ErrorClass(message);
 }
 //#endregion
 //#region src/utils/errors.ts
 /** Any failure runset reports itself; `exitCode` is what the CLI exits with. */
 var RunsetError = class extends Error {
 	exitCode;
-	/** What the CLI prints in place of `message`; empty when it already said so. */
+	/**
+	* What the CLI prints in place of `message`; empty when it already said so.
+	* @internal
+	*/
 	report;
 	constructor(message, exitCode = 1, report) {
 		super(message);
@@ -41,107 +117,44 @@ var ConfigError = class extends RunsetError {};
 /** A command that cannot be resolved. */
 var NormalizeError = class extends RunsetError {};
 //#endregion
-//#region src/utils/terminal.ts
-/**
-* Measuring and wrapping text the way a terminal lays it out: escape sequences
-* take no room, wide characters (CJK, emoji) take two columns.
-*/
-const ESCAPE = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007\u001B]*(?:\u0007|\u001B\\)?|[@-Z\\-_])/g;
-const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function isTerminal(stream) {
-	return stream.isTTY === true;
-}
-/** The width a terminal stream reports; `undefined` for anything else. */
-function terminalColumns(stream) {
-	const { columns } = stream;
-	return isTerminal(stream) && columns > 0 ? columns : void 0;
+//#region src/utils/glob.ts
+function isGlob(pattern) {
+	return pattern.includes("*");
 }
-/** `COLUMNS` as a positive integer, or `undefined`. */
-function parseColumns(value) {
-	const columns = Number(value);
-	return Number.isInteger(columns) && columns > 0 ? columns : void 0;
+/** The `names` a glob matches, in declared order; none is not an error. */
+function matchGlob(pattern, names) {
+	const regexp = toRegExp(pattern);
+	return names.filter((name) => regexp.test(name));
 }
-/** The columns `text` takes on screen. */
-function visibleWidth(text) {
-	let width = 0;
-	for (const { segment } of segmenter.segment(text.replace(ESCAPE, ""))) width += columnWidth(segment, width);
-	return width;
+function escape(literal) {
+	return literal.replaceAll(/[$()+.?[\\\]^{|}]/g, String.raw`\$&`);
 }
 /**
-* Hard-wraps one line to `width` columns, the way the terminal would have, so
-* each piece can carry a label of its own. A style still open at a break is
-* reset at the end of the piece and re-applied at the start of the next, so a
-* label never inherits it. `offset` is the column the line starts at, for tab
-* stops. A line that moves the cursor — `\r`, or any escape but a color — is
-* left whole: where it lands is not something runset can know.
+* `*` matches within one `:`-separated segment, `**` spans one or more.
+* `build:**:*` means `build:**`.
 */
-function wrapLine(line, width, offset = 0) {
-	const fits = line.length * 2 <= width && !line.includes("	");
-	if (width < 1 || fits || line.includes("\r")) return [line];
-	const pieces = [];
-	let current = "";
-	let column = 0;
-	let style = [];
-	for (const token of tokenize(line)) {
-		if (token.escape) {
-			if (token.text.startsWith("\x1B[") && !isSgr(token.text)) return [line];
-			current += token.text;
-			style = applySgr(style, token.text);
-			continue;
-		}
-		for (const { segment } of segmenter.segment(token.text)) {
-			let size = columnWidth(segment, offset + column);
-			if (column > 0 && column + size > width) {
-				pieces.push(style.length > 0 ? `${current}\u001B[0m` : current);
-				current = style.join("");
-				column = 0;
-				size = columnWidth(segment, offset);
-			}
-			current += segment;
-			column += size;
-		}
-	}
-	pieces.push(current);
-	return pieces;
-}
-function tokenize(text) {
-	const tokens = [];
-	let last = 0;
-	for (const match of text.matchAll(ESCAPE)) {
-		if (match.index > last) tokens.push({
-			escape: false,
-			text: text.slice(last, match.index)
-		});
-		tokens.push({
-			escape: true,
-			text: match[0]
-		});
-		last = match.index + match[0].length;
+function toRegExp(pattern) {
+	const segments = pattern.split(":");
+	const source = [];
+	for (const [index, segment] of segments.entries()) {
+		if (segment === "*" && segments[index - 1] === "**") continue;
+		if (segment === "**") source.push(String.raw`[^:]+(?::[^:]+)*`);
+		else source.push(segment.split("*").map((part) => escape(part)).join("[^:]*"));
 	}
-	if (last < text.length) tokens.push({
-		escape: false,
-		text: text.slice(last)
-	});
-	return tokens;
+	return new RegExp(`^${source.join(":")}$`);
 }
-/** A color or style (`ESC [ … m`); any other CSI moves the cursor. */
-function isSgr(sequence) {
-	return sequence.startsWith("\x1B[") && sequence.endsWith("m");
+//#endregion
+//#region src/utils/string.ts
+function toCamelCase(name) {
+	return name.replaceAll(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
-/** The SGR sequences in force after `sequence`; a reset clears them. */
-function applySgr(style, sequence) {
-	if (!isSgr(sequence)) return style;
-	const params = sequence.slice(2, -1);
-	if (params === "" || params === "0") return [];
-	return params.startsWith("0;") ? [sequence] : [...style, sequence];
+function toKebabCase(name) {
+	return name.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
 }
-/** The columns one grapheme takes when it starts at `column`. */
-function columnWidth(grapheme, column) {
-	if (grapheme === "	") return 8 - column % 8;
-	if (/^[ -~]$/.test(grapheme)) return 1;
-	if (/^[\p{Cc}\p{Cf}\p{Mn}\p{Me}]+$/u.test(grapheme)) return 0;
-	if (/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(grapheme) && /\p{Emoji_Presentation}|\uFE0F/u.test(grapheme)) return 2;
-	return /^[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{20000}-\u{3FFFD}]/u.test(grapheme) ? 2 : 1;
+/** `850ms` under a second, `2.1s` from one up. */
+function formatDuration(ms) {
+	const rounded = Math.round(ms);
+	return rounded < 1e3 ? `${rounded}ms` : `${(ms / 1e3).toFixed(1)}s`;
 }
 //#endregion
 //#region src/utils/fs.ts
@@ -150,13 +163,26 @@ const require = createRequire(import.meta.url);
 function importSync(modulePath) {
 	return require(modulePath);
 }
+/** `dir` and every directory above it, up to the root. */
+function ancestors(dir) {
+	const dirs = [path.resolve(dir)];
+	for (;;) {
+		const current = dirs.at(-1);
+		const parent = path.dirname(current);
+		if (parent === current) return dirs;
+		dirs.push(parent);
+	}
+}
+/** A parsed JSON file, or `undefined` when there is none. */
+function readJson(filePath) {
+	return fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, "utf8")) : void 0;
+}
 /** The nearest `package.json` at or above `cwd`. */
 function readPackageJson(cwd) {
 	for (const dir of ancestors(cwd)) {
 		const filePath = path.join(dir, "package.json");
-		if (!fs.existsSync(filePath)) continue;
-		const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
-		return {
+		const raw = readJson(filePath);
+		if (raw !== void 0) return {
 			filePath,
 			name: raw.name ?? "",
 			scripts: raw.scripts ?? {},
@@ -171,1351 +197,1324 @@ function readPackageJson(cwd) {
 	};
 }
 //#endregion
-//#region src/config/loadConfig.ts
+//#region src/utils/workspace.ts
 /**
-* Loads `runset.config.*` — the `explicitPath`, or the first one found walking
-* up from `cwd`, where a `package.json` `runset` section counts as one too —
-* and unwraps a default export or a factory function.
+* The packages of the workspace at or above `cwd`, from `pnpm-workspace.yaml`
+* or `package.json` `workspaces`, sorted by path; the root is not one of them.
 */
-function loadConfigJs({ argv, cwd, env, explicitPath }) {
-	const context = {
-		argv,
-		cwd,
-		env
-	};
-	if (explicitPath === void 0) return unwrapConfigJs(findConfigJs(cwd) ?? {}, context);
-	const filePath = path.resolve(cwd, explicitPath);
-	if (!fs.existsSync(filePath)) throw new ConfigError(`Config file not found: ${explicitPath}`);
-	return unwrapConfigJs(importSync(filePath), context);
-}
-function unwrapConfigJs(source, context) {
-	const unwrapped = source.default ?? source;
-	return typeof unwrapped === "function" ? unwrapped(context) : unwrapped;
-}
-/** `dir` and every directory above it, up to the root. */
-function ancestors(dir) {
-	const dirs = [path.resolve(dir)];
-	for (;;) {
-		const current = dirs.at(-1);
-		const parent = path.dirname(current);
-		if (parent === current) return dirs;
-		dirs.push(parent);
+function readWorkspacePackages(cwd) {
+	for (const dir of ancestors(cwd)) {
+		const patterns = readWorkspacePatterns(dir);
+		if (patterns === void 0) continue;
+		const include = patterns.filter((pattern) => !pattern.startsWith("!"));
+		const exclude = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+		return fs.globSync(include, {
+			cwd: dir,
+			exclude: [...exclude, "**/node_modules"]
+		}).map((match) => path.join(dir, match, "package.json")).filter((filePath) => fs.existsSync(filePath)).toSorted().map((filePath) => readPackageJson(path.dirname(filePath)));
 	}
+	return [];
 }
-/**
-* The nearest config walking up from `cwd`. Within one directory a
-* `runset.config.*` file wins over the `package.json` `runset` section.
-*/
-function findConfigJs(cwd) {
-	for (const dir of ancestors(cwd)) {
-		for (const extension of [
-			"ts",
-			"js",
-			"mjs",
-			"cjs",
-			"json"
-		]) {
-			const candidate = path.join(dir, `runset.config.${extension}`);
-			if (fs.existsSync(candidate)) return importSync(candidate);
-		}
-		const section = readPackageJsonSection(path.join(dir, "package.json"));
-		if (section !== void 0) return section;
-	}
+function readWorkspacePatterns(dir) {
+	const yamlPath = path.join(dir, "pnpm-workspace.yaml");
+	if (fs.existsSync(yamlPath)) return parsePnpmPackages(fs.readFileSync(yamlPath, "utf8"));
+	const { workspaces } = readJson(path.join(dir, "package.json")) ?? {};
+	return Array.isArray(workspaces) ? workspaces : workspaces?.packages;
 }
-function readPackageJsonSection(filePath) {
-	if (!fs.existsSync(filePath)) return;
-	const { runset } = JSON.parse(fs.readFileSync(filePath, "utf8"));
-	if (runset === void 0) return;
-	if (runset === null || typeof runset !== "object" || Array.isArray(runset)) throw new ConfigError(`${filePath}: "runset" must be an object`);
-	return runset;
+/** The `packages:` list of a `pnpm-workspace.yaml`, read without a YAML parser. */
+function parsePnpmPackages(text) {
+	const patterns = [];
+	let inPackages = false;
+	for (const raw of text.split(/\r?\n/)) {
+		const line = raw.replace(/\s#.*$/, "").trimEnd();
+		if (/^\S/.test(line)) inPackages = /^packages\s*:/.test(line);
+		else if (inPackages && /^\s+-/.test(line)) patterns.push(line.replace(/^\s+-\s*/, "").replaceAll(/^['"]|['"]$/g, ""));
+	}
+	return patterns;
 }
 //#endregion
-//#region src/utils/string.ts
-function toCamelCase(name) {
-	return name.replaceAll(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+//#region src/utils/os.ts
+/** 128 + the signal's number, the way a shell reports it: 130, 143, … */
+function signalExitCode(signal) {
+	return 128 + (os.constants.signals[signal] ?? 15);
 }
-function toKebabCase(name) {
-	return name.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+/**
+* Quotes a value so the platform's shell passes it on as literal text —
+* double quotes are not enough, since `$(…)` still runs inside them.
+*/
+function quoteForShell(value, platform = process.platform) {
+	return platform === "win32" ? quoteForCmd(value) : quoteForPosix(value);
 }
-/** `850ms` under a second, `2.1s` from one up. */
-function formatDuration(ms) {
-	const rounded = Math.round(ms);
-	return rounded < 1e3 ? `${rounded}ms` : `${(ms / 1e3).toFixed(1)}s`;
+/** Single quotes are fully literal; each `'` inside closes, escapes, reopens. */
+function quoteForPosix(value) {
+	return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}
+/**
+* Quoted for the C runtime first, then every `cmd.exe` metacharacter
+* `^`-escaped (see <https://qntm.org/cmd>). Newlines cannot survive `cmd.exe`,
+* so they become spaces.
+*/
+function quoteForCmd(value) {
+	return `"${value.replaceAll("\r\n", " ").replaceAll(/[\n\r]/g, " ").replaceAll(/(\\*)"/g, String.raw`$1$1\"`).replace(/(\\*)$/, "$1$1")}"`.replaceAll(/["%&()<>^|]/g, (character) => `^${character}`);
 }
 //#endregion
-//#region src/config/winArgv.ts
+//#region src/plan/placeholders.ts
 /**
-* Windows only: rejoins `'single quoted'` tokens that `cmd.exe` leaves split,
-* joined by single spaces. The identity everywhere else.
+* Fills `{1}`, `{@}`, `{*}` and `{name}` from the arguments after `--`.
+*
+* In a command line values are shell-quoted and unknown names left as written
+* (`${HOME}`); in an option (`forOption`) values are raw and unknown names
+* are empty, so `disabled={noTest}` is false when nothing was passed.
 */
-function regroupQuoted(argv, platform = process.platform) {
-	if (platform !== "win32") return argv;
-	const result = [];
-	let open;
-	for (const token of argv) {
-		if (open === void 0) {
-			if (token.startsWith("'") && token.endsWith("'") && token.length > 1) result.push(token.slice(1, -1));
-			else if (token.startsWith("'")) open = [token.slice(1)];
-			else result.push(token);
-			continue;
+function substitutePlaceholders(text, args, forOption = false) {
+	const PLACEHOLDER = /\{([^\s{}]*)\}/g;
+	const wrap = forOption ? (value) => value : quoteForShell;
+	return text.replaceAll(PLACEHOLDER, (match, key) => {
+		if (key === "@") return args.map((arg) => wrap(arg)).join(" ");
+		if (key === "*") return args.length === 0 ? "" : wrap(args.join(" "));
+		if (/^[1-9]\d*$/.test(key)) {
+			const value = args[Number(key) - 1];
+			return value === void 0 ? "" : wrap(value);
 		}
-		if (token.endsWith("'")) {
-			open.push(token.slice(0, -1));
-			result.push(open.join(" "));
-			open = void 0;
-		} else open.push(token);
+		const named = namedValue(key, args);
+		if (named !== void 0) return wrap(named);
+		return forOption ? "" : match;
+	});
+}
+/**
+* The value of `--name=value` or `--name value` (camel or kebab); a bare
+* `--name` is `'true'`.
+*/
+function namedValue(key, args) {
+	for (const [index, token] of args.entries()) {
+		if (!token.startsWith("--") || token.length === 2) continue;
+		const equals = token.indexOf("=");
+		if (toCamelCase(equals === -1 ? token.slice(2) : token.slice(2, equals)) !== key) continue;
+		if (equals !== -1) return token.slice(equals + 1);
+		const next = args[index + 1];
+		return next !== void 0 && !next.startsWith("-") ? next : "true";
 	}
-	if (open !== void 0) throw new CliError(`Unterminated quote in "'${open.join(" ")}".`);
-	return result;
 }
 //#endregion
-//#region src/config/parseCli.ts
-const FLAGS = [
-	{
-		name: "parallel",
-		short: "p",
-		takesValue: false
-	},
-	{
-		name: "serial",
-		short: "s",
-		takesValue: false
-	},
-	{
-		name: "recursive",
-		short: "r",
-		takesValue: false
-	},
-	{
-		name: "jobs",
-		short: "j",
-		takesValue: true
-	},
-	{
-		name: "killTimeout",
-		takesValue: true
-	},
-	{
-		name: "onSuccess",
-		takesValue: true
-	},
-	{
-		name: "onFailure",
-		takesValue: true
-	},
-	{
-		name: "config",
-		short: "c",
-		takesValue: true
-	},
-	{
-		name: "cwd",
-		takesValue: true
-	},
-	{
-		name: "env",
-		short: "e",
-		takesValue: true
-	},
-	{
-		name: "color",
-		negated: "none",
-		takesValue: true
-	},
-	{
-		name: "logLevel",
-		takesValue: true
-	},
-	{
-		name: "dryRun",
-		takesValue: false
-	},
-	{
-		name: "stdout",
-		takesValue: true
-	},
-	{
-		name: "stderr",
-		takesValue: true
-	},
-	{
-		name: "output",
-		short: "o",
-		takesValue: true
-	},
-	{
-		name: "labels",
-		takesValue: true
-	},
-	{
-		name: "showCommand",
-		takesValue: false
-	},
-	{
-		name: "showExitCode",
-		takesValue: false
-	},
-	{
-		name: "wrap",
-		short: "w",
-		takesValue: false
-	},
-	{
-		name: "help",
-		short: "h",
-		takesValue: false
-	},
-	{
-		name: "version",
-		short: "v",
-		takesValue: false
-	}
-];
+//#region src/plan/stages.ts
+const EMPTY_SEGMENT = {
+	commands: [],
+	parallel: false
+};
+/** A `-p`/`-s`: what follows starts a new group past everything before it. */
+const BOUNDARY = {
+	boundary: true,
+	commands: [],
+	parallel: false
+};
 /**
-* Splits argv into options, commands, and the literal arguments after `--`.
-* Each `-p`/`-s` becomes a settings entry where it was typed, the same object
-* a config file would write.
+* Lays segments out into stages. A parallel segment joins the open stage;
+* anything else starts past every stage in use, and so does what follows it.
+* A segment's commands keep their relative stages, shifted onto its own.
 */
-function parseCli(rawArgv) {
-	const argv = regroupQuoted(rawArgv);
-	const options = {};
+function link(segments) {
 	const commands = [];
-	const positional = [];
-	let help = false;
-	let version = false;
-	let afterDoubleDash = false;
-	let cursor = 0;
-	function setOption(spec, raw) {
-		switch (spec.name) {
-			case "env": {
-				const text = String(raw);
-				const eq = text.indexOf("=");
-				if (eq < 1) throw new CliError(`Option "--env" takes NAME=value, not "${text}".`);
-				(options.env ??= {})[text.slice(0, eq)] = text.slice(eq + 1);
-				break;
-			}
-			case "help":
-				help = true;
-				break;
-			case "jobs":
-			case "killTimeout":
-				options[spec.name] = Number(raw);
-				break;
-			case "parallel":
-			case "serial":
-				commands.push({ parallel: spec.name === "parallel" });
-				break;
-			case "version":
-				version = true;
-				break;
-			default: if (typeof raw === "boolean") options[spec.name] = raw;
-			else options[spec.name] = raw;
-		}
-	}
-	function takeValue(label) {
-		const value = argv[cursor + 1];
-		if (value === void 0) throw new CliError(`Option "${label}" needs a value.`);
-		cursor += 1;
-		return value;
-	}
-	function readLong(body) {
-		const eq = body.indexOf("=");
-		const name = eq === -1 ? body : body.slice(0, eq);
-		const inlineValue = eq === -1 ? void 0 : body.slice(eq + 1);
-		const flag = findLongFlag(name);
-		if (flag === void 0 && /^no-?[A-Za-z]/.test(name)) {
-			const negated = findLongFlag(name.replace(/^no-?/, ""));
-			if (negated && (!negated.takesValue || negated.negated !== void 0)) {
-				setOption(negated, negated.negated ?? false);
-				return;
-			}
+	/** The stage a parallel segment joins. */
+	let open = 0;
+	/** The last stage in use; -1 while none is. */
+	let used = -1;
+	for (const segment of segments) {
+		if (segment.boundary) {
+			open = used + 1;
+			continue;
 		}
-		if (flag === void 0) throw new CliError(`Unknown option "--${name}".`);
-		if (flag.takesValue) setOption(flag, inlineValue ?? takeValue(`--${name}`));
-		else setOption(flag, true);
-	}
-	function readShortCluster(body) {
-		for (let position = 0; position < body.length; position += 1) {
-			const letter = body[position];
-			const flag = findShortFlag(letter);
-			if (flag === void 0) throw new CliError(`Unknown option "-${letter}".`);
-			if (!flag.takesValue) {
-				setOption(flag, true);
-				continue;
-			}
-			const rest = body.slice(position + 1);
-			setOption(flag, rest === "" ? takeValue(`-${letter}`) : rest);
-			return;
+		if (segment.commands.length === 0) continue;
+		const base = segment.parallel ? open : used + 1;
+		for (const command of segment.commands) {
+			command.stage += base;
+			used = Math.max(used, command.stage);
+			commands.push(command);
 		}
+		open = segment.parallel ? open : used + 1;
 	}
-	for (; cursor < argv.length; cursor += 1) {
-		const token = argv[cursor];
-		if (afterDoubleDash) positional.push(token);
-		else if (token === "--") afterDoubleDash = true;
-		else if (token.startsWith("--") && token.length > 2) readLong(token.slice(2));
-		else if (token.startsWith("-") && token.length > 1) readShortCluster(token.slice(1));
-		else commands.push(token);
-	}
-	return {
-		argv,
-		commands,
-		help,
-		options,
-		positional,
-		version
-	};
-}
-function findLongFlag(name) {
-	const camel = toCamelCase(name);
-	return FLAGS.find((flag) => flag.name === camel);
+	return commands;
 }
-function findShortFlag(letter) {
-	return FLAGS.find((flag) => flag.short === letter);
+/** Splits a stage-sorted list into its stages, in order. */
+function groupByStage(items, stageOf) {
+	return [...Map.groupBy(items, stageOf).values()];
 }
 //#endregion
-//#region src/config/std.ts
-const TIMINGS = /* @__PURE__ */ new Set(["realtime", "grouped"]);
+//#region src/plan/token.ts
+const BOOLEAN_OPTIONS = [
+	"disabled",
+	"parallel",
+	"recursive"
+];
+const ACTION_OPTIONS = ["onFailure", "onSuccess"];
+/** Keys a `::` suffix may set. */
+const INLINE_OPTIONS = /* @__PURE__ */ new Set([
+	"bgColor",
+	"color",
+	"cwd",
+	"label",
+	"output",
+	"stderr",
+	"stdout",
+	...BOOLEAN_OPTIONS,
+	...ACTION_OPTIONS
+]);
 /**
-* Parses `<timing>+<destination>` (either order, either optional) into the
-* axes it names. Unnamed axes are left out so settings can be layered.
+* Splits `"name args::options"` at the last `::`. The options run to the end
+* of the string, so a trailing space stays part of the last value.
 */
-function parsePartialStd(value) {
-	const result = {};
-	for (const part of value.split("+")) {
-		const token = part.trim();
-		if (token === "") continue;
-		if (TIMINGS.has(token)) result.timing = token;
-		else result.destination = token;
-	}
-	return result;
-}
-function toPartialStd(value) {
-	return typeof value === "string" ? parsePartialStd(value) : value;
-}
-/** Layers a stream setting, in either form, over `base` one axis at a time. */
-function mergeStd(base, value) {
-	return value === void 0 ? base : {
-		...base,
-		...toPartialStd(value)
-	};
-}
-function defaultStd(destination) {
+function splitToken(raw) {
+	const trimmed = raw.trimStart();
+	const marker = trimmed.lastIndexOf("::");
+	const command = (marker === -1 ? trimmed : trimmed.slice(0, marker)).trim();
+	const space = command.search(/\s/);
 	return {
-		destination,
-		timing: "realtime"
+		args: space === -1 ? "" : command.slice(space + 1).trim(),
+		name: space === -1 ? command : command.slice(0, space),
+		options: marker === -1 ? "" : trimmed.slice(marker + 2)
 	};
 }
-//#endregion
-//#region src/config/validate.ts
-function formatValue(value) {
-	return typeof value === "string" ? `"${value}"` : String(value);
-}
-function numberError(name, value, minimum) {
-	if (typeof value !== "number" || Number.isNaN(value) || value < minimum) return `${name} must be a number of ${minimum} or more, got ${formatValue(value)}.`;
-}
-function booleanError(name, value) {
-	return typeof value === "boolean" ? void 0 : `${name} must be true or false, got ${formatValue(value)}.`;
-}
-function stringError(name, value) {
-	return typeof value === "string" ? void 0 : `${name} must be a string, got ${formatValue(value)}.`;
-}
-function envError(name, value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return `${name} must be an object.`;
-	const bad = Object.entries(value).find(([, entry]) => typeof entry !== "string");
-	return bad === void 0 ? void 0 : `${name}.${bad[0]} must be a string, got ${formatValue(bad[1])}.`;
-}
-function oneOfError(name, value, allowed) {
-	return allowed.has(value) ? void 0 : `${name} is one of ${[...allowed].join(", ")}, got ${formatValue(value)}.`;
-}
-function actionError(name, value) {
-	return oneOfError(name, value, EXIT_ACTIONS);
-}
-function stdError(name, value) {
-	if (typeof value !== "object" || value === null) return `${name} must be a stream setting.`;
-	if (!TIMINGS.has(value.timing)) return `Invalid timing ${formatValue(value.timing)} for ${name}; one of ${[...TIMINGS].join(", ")}.`;
-	if (typeof value.destination !== "string" || value.destination === "") return `${name} needs a destination to write to.`;
-}
-/** Throws `message` as an `ErrorClass`, if there is one. */
-function check(message, ErrorClass) {
-	if (message !== void 0) throw new ErrorClass(message);
+/**
+* Parses `key=value,flag`. Split before placeholders are filled, so a `,` or
+* `=` arriving in a value cannot inject another option.
+*/
+function parseInlineOptions(text, args) {
+	const options = {};
+	for (const entry of text.split(",")) {
+		if (entry.trim() === "") continue;
+		const eq = entry.indexOf("=");
+		const key = toCamelCase((eq === -1 ? entry : entry.slice(0, eq)).trim());
+		const written = eq === -1 ? "true" : entry.slice(eq + 1);
+		const value = substitutePlaceholders(key === "label" ? written : written.trim(), args, true);
+		if (!INLINE_OPTIONS.has(key)) throw new NormalizeError(`Unknown command option "${toKebabCase(key)}" in "::${text.trim()}".`);
+		if (key === "output" || key === "stderr" || key === "stdout") options[key] = parsePartialStd(value);
+		else if (BOOLEAN_OPTIONS.includes(key)) options[key] = value !== "false" && value !== "";
+		else if (ACTION_OPTIONS.includes(key)) {
+			check(actionError(`"${toKebabCase(key)}"`, value), NormalizeError);
+			options[key] = value;
+		} else options[key] = value;
+	}
+	return options;
 }
 //#endregion
-//#region src/config/Config.ts
-const DEFAULT_KILL_TIMEOUT = 5e3;
-const LOG_LEVELS = /* @__PURE__ */ new Set([
-	"error",
-	"warn",
-	"info",
-	"debug"
-]);
-const LABEL_MODES = /* @__PURE__ */ new Set([
-	"none",
-	"auto",
-	"custom",
-	"all"
-]);
-const COLOR_MODES = /* @__PURE__ */ new Set([
-	"auto",
-	"none",
-	"basic",
-	"soft",
-	"all"
-]);
-const KNOWN_KEYS = /* @__PURE__ */ new Set([
-	"color",
-	"scripts",
-	"commands",
-	"cwd",
-	"dryRun",
+//#region src/plan/normalize.ts
+/** Keys a settings entry may set. */
+const SETTINGS_OPTIONS = /* @__PURE__ */ new Set([
+	...INLINE_OPTIONS,
 	"env",
-	"formatLabel",
-	"jobs",
-	"killTimeout",
-	"labels",
-	"logLevel",
-	"onFailure",
-	"onSuccess",
-	"output",
-	"parallel",
-	"recursive",
-	"showCommand",
-	"showExitCode",
-	"stderr",
-	"stdout",
-	"wrap"
+	"serial"
 ]);
-/** Parses, loads and validates; anything left out comes from the process. */
-function createConfig({ cli = parseCli(process.argv.slice(2)), configJs, cwd = process.cwd(), destinations = process, env = process.env } = {}) {
-	const config = new Config({
-		cli,
-		configJs,
-		cwd,
-		destinations,
-		env
-	});
-	config.validate();
-	return config;
-}
-/** The resolved run-wide configuration: CLI flag → config file → default. */
-var Config = class {
-	commands;
-	scripts;
-	/** Everything after `--`, for placeholders. */
-	args;
-	cwd;
-	env;
-	jobs;
-	killTimeout;
-	onSuccess;
-	onFailure;
-	color;
-	parallel;
-	recursive;
-	showCommand;
-	showExitCode;
-	wrap;
-	/** `COLUMNS` as runset was started with it: the width where no TTY says. */
-	envColumns;
-	labels;
-	logLevel;
-	dryRun;
-	formatLabel;
-	stdout;
-	stderr;
-	destinations;
-	/** Printed by the run once it is built. */
-	warnings = [];
-	constructor({ cli, configJs, cwd, destinations, env }) {
-		const { options } = cli;
-		this.cwd = path.resolve(cwd, options.cwd ?? ".");
-		this.destinations = destinations;
-		const context = {
-			argv: cli.argv,
-			cwd: this.cwd,
-			env
+/**
+* Turns `config.commands` into the run's commands: flat, validated, numbered
+* by stage and sorted by it.
+*/
+function normalize(config, packageInfo) {
+	let workspacePackages;
+	const defaults = {
+		bgColor: "",
+		color: "",
+		command: "",
+		cwd: config.cwd,
+		env: {},
+		label: "",
+		line: "",
+		onFailure: config.onFailure,
+		onSuccess: config.onSuccess,
+		stage: 0,
+		stderr: config.stderr,
+		stdout: config.stdout,
+		type: "shell"
+	};
+	function makeLeaf(token, rawOptions, script, pkg = packageInfo) {
+		const { disabled, parallel, recursive, ...own } = rawOptions;
+		const options = {
+			...own,
+			stderr: mergeStd(defaults.stderr, own.stderr),
+			stdout: mergeStd(defaults.stdout, own.stdout)
 		};
-		const file = configJs === void 0 ? loadConfigJs({
-			...context,
-			explicitPath: options.config
-		}) : unwrapConfigJs(configJs, context);
-		for (const key of Object.keys(file)) if (!KNOWN_KEYS.has(key)) this.warnings.push(`Unknown config key "${key}" was ignored.`);
-		if (file.cwd !== void 0 && options.cwd === void 0) this.cwd = path.resolve(cwd, file.cwd);
-		check(envError("env", file.env ?? {}), ConfigError);
-		this.env = {
-			...env,
-			...file.env,
-			...options.env
+		const args = substitutePlaceholders(token.args, config.args);
+		const command = [token.name, args].filter((part) => part !== "").join(" ");
+		const line = script === void 0 ? command : [pkg.scripts[script], args].filter((part) => part !== "").join(" ");
+		const leaf = {
+			...defaults,
+			...options,
+			command,
+			line,
+			stage: 0,
+			type: script === void 0 ? "shell" : "npm",
+			...script === void 0 ? {} : { scriptName: script },
+			...pkg === packageInfo ? {} : { packageName: packageNameOf(pkg) }
 		};
-		this.commands = [...file.commands ?? [], ...cli.commands].filter(Boolean);
-		this.scripts = file.scripts ?? {};
-		this.args = cli.positional;
-		this.jobs = options.jobs ?? file.jobs ?? Number.POSITIVE_INFINITY;
-		this.killTimeout = options.killTimeout ?? file.killTimeout ?? DEFAULT_KILL_TIMEOUT;
-		this.parallel = file.parallel ?? false;
-		this.recursive = options.recursive ?? file.recursive ?? false;
-		this.showCommand = options.showCommand ?? file.showCommand ?? false;
-		this.showExitCode = options.showExitCode ?? file.showExitCode ?? false;
-		this.wrap = options.wrap ?? file.wrap ?? false;
-		this.envColumns = parseColumns(env.COLUMNS);
-		this.labels = options.labels ?? file.labels ?? "auto";
-		this.onSuccess = options.onSuccess ?? file.onSuccess ?? "continue";
-		this.onFailure = options.onFailure ?? file.onFailure ?? "stop";
-		this.dryRun = options.dryRun ?? file.dryRun ?? false;
-		this.logLevel = options.logLevel ?? file.logLevel ?? "info";
-		this.color = resolveColor(options.color ?? file.color, env, destinations);
-		this.formatLabel = file.formatLabel;
-		const std = (stream) => {
-			let result = defaultStd(stream);
-			for (const value of [
-				file.output,
-				file[stream],
-				options.output,
-				options[stream]
-			]) result = mergeStd(result, value);
-			return result;
+		if (script !== void 0 && options.cwd === void 0) leaf.cwd = pkg.filePath === "" ? config.cwd : path.dirname(pkg.filePath);
+		validateCommand(leaf, {
+			disabled,
+			parallel,
+			recursive
+		});
+		return leaf;
+	}
+	/** Links one token's commands (e.g. glob matches) by their `parallel`. */
+	function toSegment(leaves, settled) {
+		const parallel = settled.parallel ?? config.parallel;
+		return {
+			commands: settled.disabled ? [] : link(leaves.map((leaf) => ({
+				commands: [leaf],
+				parallel
+			}))),
+			parallel
 		};
-		this.stdout = std("stdout");
-		this.stderr = std("stderr");
 	}
-	/** Throws on the first invalid value; types too, as config files are arbitrary JS. */
-	validate() {
-		check([
-			oneOfError("logLevel", this.logLevel, LOG_LEVELS),
-			numberError("jobs", this.jobs, 1),
-			numberError("killTimeout", this.killTimeout, 0),
-			oneOfError("color", this.color, COLOR_MODES),
-			booleanError("parallel", this.parallel),
-			booleanError("recursive", this.recursive),
-			booleanError("showCommand", this.showCommand),
-			booleanError("showExitCode", this.showExitCode),
-			booleanError("wrap", this.wrap),
-			booleanError("dryRun", this.dryRun),
-			oneOfError("labels", this.labels, LABEL_MODES),
-			stdError("stdout", this.stdout),
-			stdError("stderr", this.stderr),
-			this.formatLabel !== void 0 && typeof this.formatLabel !== "function" ? "formatLabel must be a function." : void 0,
-			typeof this.scripts !== "object" || this.scripts === null || Array.isArray(this.scripts) ? "scripts must be an object." : void 0,
-			actionError("onSuccess", this.onSuccess),
-			actionError("onFailure", this.onFailure)
-		].find((error) => error !== void 0), ConfigError);
+	function resolveToken(raw, inherited, overrides, seen) {
+		const token = splitToken(raw);
+		const inline = resolveCwd(parseInlineOptions(token.options, config.args), inherited.cwd ?? config.cwd);
+		if (Object.hasOwn(config.scripts, token.name)) {
+			if (seen.has(token.name)) throw new NormalizeError(`Command "${token.name}" refers to itself.`);
+			const resolved = resolveEntry(config.scripts[token.name], inherited, layer(inline, overrides), /* @__PURE__ */ new Set([...seen, token.name]));
+			return token.args === "" ? resolved : appendArgs(resolved, token);
+		}
+		const settled = layer(inherited, inline, overrides);
+		if (settled.recursive ?? config.recursive) {
+			workspacePackages ??= readWorkspacePackages(config.cwd);
+			const leaves = workspacePackages.flatMap((pkg) => matchScripts(token.name, pkg).map((name) => makeLeaf({
+				...token,
+				name
+			}, settled, name, pkg)));
+			if (leaves.length > 0) return toSegment(leaves, settled);
+		}
+		const names = matchScripts(token.name, packageInfo);
+		return toSegment(names.length > 0 || isGlob(token.name) ? names.map((name) => makeLeaf({
+			...token,
+			name
+		}, settled, name)) : [makeLeaf(token, settled, void 0)], settled);
 	}
-	/** True when `commands` holds something to run, not just settings entries. */
-	hasCommands() {
-		return this.commands.some((command) => typeof command === "object" && command !== null ? !isCommandSettings(command) : Boolean(command));
+	function appendArgs(segment, token) {
+		const [leaf] = segment.commands;
+		if (segment.commands.length !== 1 || leaf === void 0) throw new NormalizeError(`Cannot pass arguments to "${token.name}": it expands to more than one command.`);
+		const args = substitutePlaceholders(token.args, config.args);
+		const extended = {
+			...leaf,
+			command: `${leaf.command} ${args}`,
+			line: `${leaf.line} ${args}`
+		};
+		return {
+			...segment,
+			commands: [extended]
+		};
 	}
-};
+	/** One list entry other than a settings entry. */
+	function resolve(definition, inherited, overrides, seen) {
+		if (!definition) return EMPTY_SEGMENT;
+		if (typeof definition === "string") return resolveToken(definition, inherited, overrides, seen);
+		if (Array.isArray(definition)) throw new NormalizeError("A list of commands belongs in \"commands\" or in a \"scripts\" entry, not inside one.");
+		if (isSettingsEntry(definition)) throw new NormalizeError("A command definition needs a \"command\" field.");
+		const entry = definition;
+		if (typeof entry.command !== "string") throw new NormalizeError("A command's \"command\" must be a string.");
+		const { command, ...raw } = entry;
+		return resolveToken(command, layer(inherited, resolveCwd(raw, inherited.cwd ?? config.cwd)), overrides, seen);
+	}
+	/**
+	* `commands`, or a `scripts` entry that is a list. The list's own
+	* `parallel` places the list as a whole and is not passed to its members.
+	*/
+	function resolveList(definitions, inherited, overrides, seen) {
+		const { parallel: inheritedParallel, ...passedDown } = inherited;
+		const { parallel: overriddenParallel, ...passedOver } = overrides;
+		const parallel = overriddenParallel ?? inheritedParallel ?? config.parallel;
+		check(booleanError("\"parallel\" on a list of commands", parallel), NormalizeError);
+		const segments = [];
+		let settled = passedDown;
+		for (const definition of definitions) {
+			if (isSettingsEntry(definition)) {
+				const written = readSettings(definition, settled.cwd ?? config.cwd);
+				settled = layer(settled, written);
+				if (written.parallel !== void 0) segments.push(BOUNDARY);
+				continue;
+			}
+			segments.push(resolve(definition, settled, passedOver, seen));
+		}
+		return {
+			commands: link(segments),
+			parallel
+		};
+	}
+	function resolveEntry(entry, inherited, overrides, seen) {
+		return Array.isArray(entry) ? resolveList(entry, inherited, overrides, seen) : resolve(entry, inherited, overrides, seen);
+	}
+	const { commands } = resolveList(config.commands, {}, {}, /* @__PURE__ */ new Set());
+	commands.sort((first, second) => first.stage - second.stage);
+	return commands;
+}
+/** True for an object written without a `command` — a settings entry. */
+function isSettingsEntry(definition) {
+	return typeof definition === "object" && definition !== null && !Array.isArray(definition) && !("command" in definition);
+}
+/** The scripts of `pkg` a token name matches, glob or not. */
+function matchScripts(name, pkg) {
+	if (isGlob(name)) return matchGlob(name, Object.keys(pkg.scripts));
+	return Object.hasOwn(pkg.scripts, name) ? [name] : [];
+}
+function packageNameOf(pkg) {
+	return pkg.name || path.basename(path.dirname(pkg.filePath));
+}
+/** Resolves a relative `cwd` against the inherited one, so directories nest. */
+function resolveCwd(options, base) {
+	return options.cwd === void 0 ? options : {
+		...options,
+		cwd: path.resolve(base, options.cwd)
+	};
+}
 /**
-* A mode as given; under `auto`, whether to color at all, then `soft` where
-* the terminal shows 256 colors. `all` is only ever asked for. Anything else is
-* left for `validate` to refuse.
+* Reads a settings entry into the options the rest of its list inherits.
+* Keys are checked strictly: `{ paralel: true }` would otherwise do nothing.
 */
-function resolveColor(mode, env, destinations) {
-	if (mode !== void 0 && mode !== "auto") return mode;
-	if (!detectColor(env, destinations)) return "none";
-	return WriteStream.prototype.getColorDepth(env) >= 8 ? "soft" : "basic";
+function readSettings(entry, base) {
+	const keys = Object.keys(entry);
+	if (keys.length === 0) throw new NormalizeError("A settings entry must set at least one option.");
+	for (const key of keys) if (!SETTINGS_OPTIONS.has(key)) throw new NormalizeError(`Unknown option "${toKebabCase(key)}" in a settings entry.`);
+	const { serial, ...options } = entry;
+	if (serial !== void 0) {
+		check(booleanError("\"serial\"", serial), NormalizeError);
+		if (options.parallel !== void 0) throw new NormalizeError("A settings entry takes \"parallel\" or \"serial\", not both.");
+		options.parallel = !serial;
+	}
+	return resolveCwd(options, base);
 }
-/** `NO_COLOR`/`FORCE_COLOR`, then whether both streams are TTYs. */
-function detectColor(env, destinations) {
-	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
-	if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
-	return isTerminal(destinations.stdout) && isTerminal(destinations.stderr);
+/** Layers option bags, later over earlier; stream settings merge per axis. */
+function layer(...bags) {
+	const result = {};
+	for (const { output, stderr, stdout, ...rest } of bags) Object.assign(result, rest);
+	return {
+		...result,
+		...layerStreams({
+			stderr: {},
+			stdout: {}
+		}, bags)
+	};
+}
+/**
+* Checks what a config file could have written by hand: the leaf, and the
+* options that were read while laying it out.
+*/
+function validateCommand(command, read) {
+	const where = (key) => `"${toKebabCase(key)}" on "${command.command}"`;
+	check([
+		...ACTION_OPTIONS.map((key) => actionError(where(key), command[key])),
+		...BOOLEAN_OPTIONS.map((key) => read[key] === void 0 ? void 0 : booleanError(where(key), read[key])),
+		...[
+			"bgColor",
+			"color",
+			"cwd",
+			"label"
+		].map((key) => stringError(where(key), command[key])),
+		...["stderr", "stdout"].map((key) => stdError(where(key), command[key])),
+		envError(where("env"), command.env)
+	].find((error) => error !== void 0), NormalizeError);
 }
 //#endregion
-//#region src/utils/colors.ts
-const KNOWN = new Set(Object.keys(inspect.colors));
-const SHADES = {
-	mint: {
-		index: 115,
-		fallback: "greenBright"
-	},
-	sky: {
-		index: 111,
-		fallback: "blueBright"
-	},
-	rose: {
-		index: 211,
-		fallback: "magentaBright"
-	},
-	amber: {
-		index: 179,
-		fallback: "yellowBright"
-	},
-	lavender: {
-		index: 183,
-		fallback: "magentaBright"
-	},
-	aqua: {
-		index: 80,
-		fallback: "cyanBright"
-	},
-	coral: {
-		index: 210,
-		fallback: "redBright"
-	},
-	sage: {
-		index: 151,
-		fallback: "greenBright"
+//#region src/utils/terminal.ts
+/**
+* Measuring and wrapping text the way a terminal lays it out: escape sequences
+* take no room, wide characters (CJK, emoji) take two columns.
+*/
+const ESCAPE = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007\u001B]*(?:\u0007|\u001B\\)?|[@-Z\\-_])/g;
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/** Printable ASCII only: one column per character, nothing to segment. */
+const PLAIN = /^[ -~]*$/;
+function isTerminal(stream) {
+	return stream.isTTY === true;
+}
+/** The width a terminal stream reports; `undefined` for anything else. */
+function terminalColumns(stream) {
+	const { columns } = stream;
+	return isTerminal(stream) && columns > 0 ? columns : void 0;
+}
+/** `COLUMNS` as a positive integer, or `undefined`. */
+function parseColumns(value) {
+	const columns = Number(value);
+	return Number.isInteger(columns) && columns > 0 ? columns : void 0;
+}
+/** The columns `text` takes on screen. */
+function visibleWidth(text) {
+	if (PLAIN.test(text)) return text.length;
+	let width = 0;
+	for (const { segment } of segmenter.segment(text.replace(ESCAPE, ""))) width += columnWidth(segment, width);
+	return width;
+}
+/**
+* Hard-wraps one line to `width` columns, the way the terminal would have, so
+* each piece can carry a label of its own. A style still open at a break is
+* reset at the end of the piece and re-applied at the start of the next, so a
+* label never inherits it. `offset` is the column the line starts at, for tab
+* stops. A line that moves the cursor — `\r`, or any escape but a color — is
+* left whole: where it lands is not something runset can know.
+*/
+function wrapLine(line, width, offset = 0) {
+	const fits = line.length * 2 <= width && !line.includes("	");
+	if (width < 1 || fits || line.includes("\r")) return [line];
+	if (PLAIN.test(line)) {
+		const pieces = [];
+		for (let start = 0; start < line.length; start += width) pieces.push(line.slice(start, start + width));
+		return pieces;
+	}
+	const pieces = [];
+	let current = "";
+	let column = 0;
+	let style = [];
+	for (const token of tokenize(line)) {
+		if (token.escape) {
+			if (token.text.startsWith("\x1B[") && !isSgr(token.text)) return [line];
+			current += token.text;
+			style = applySgr(style, token.text);
+			continue;
+		}
+		for (const { segment } of segmenter.segment(token.text)) {
+			let size = columnWidth(segment, offset + column);
+			if (column > 0 && column + size > width) {
+				pieces.push(style.length > 0 ? `${current}\u001B[0m` : current);
+				current = style.join("");
+				column = 0;
+				size = columnWidth(segment, offset);
+			}
+			current += segment;
+			column += size;
+		}
+	}
+	pieces.push(current);
+	return pieces;
+}
+function tokenize(text) {
+	const tokens = [];
+	let last = 0;
+	for (const match of text.matchAll(ESCAPE)) {
+		if (match.index > last) tokens.push({
+			escape: false,
+			text: text.slice(last, match.index)
+		});
+		tokens.push({
+			escape: true,
+			text: match[0]
+		});
+		last = match.index + match[0].length;
+	}
+	if (last < text.length) tokens.push({
+		escape: false,
+		text: text.slice(last)
+	});
+	return tokens;
+}
+/** A color or style (`ESC [ … m`); any other CSI moves the cursor. */
+function isSgr(sequence) {
+	return sequence.startsWith("\x1B[") && sequence.endsWith("m");
+}
+/** The SGR sequences in force after `sequence`; a reset clears them. */
+function applySgr(style, sequence) {
+	if (!isSgr(sequence)) return style;
+	const params = sequence.slice(2, -1);
+	if (params === "" || params === "0") return [];
+	return params.startsWith("0;") ? [sequence] : [...style, sequence];
+}
+/** The columns one grapheme takes when it starts at `column`. */
+function columnWidth(grapheme, column) {
+	if (grapheme === "	") return 8 - column % 8;
+	if (/^[ -~]$/.test(grapheme)) return 1;
+	if (/^[\p{Cc}\p{Cf}\p{Mn}\p{Me}]+$/u.test(grapheme)) return 0;
+	if (/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(grapheme) && /\p{Emoji_Presentation}|\uFE0F/u.test(grapheme)) return 2;
+	return /^[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{20000}-\u{3FFFD}]/u.test(grapheme) ? 2 : 1;
+}
+//#endregion
+//#region src/config/loadConfig.ts
+/**
+* Loads `runset.config.*` — the `explicitPath`, or the first one found walking
+* up from `cwd`, where a `package.json` `runset` section counts as one too —
+* and unwraps a default export or a factory function.
+*/
+function loadConfigJs(context, explicitPath) {
+	if (explicitPath === void 0) return unwrapConfigJs(findConfigJs(context.cwd) ?? {}, context);
+	const filePath = path.resolve(context.cwd, explicitPath);
+	if (!fs.existsSync(filePath)) throw new ConfigError(`Config file not found: ${explicitPath}`);
+	return unwrapConfigJs(importSync(filePath), context);
+}
+function unwrapConfigJs(source, context) {
+	const unwrapped = source.default ?? source;
+	return typeof unwrapped === "function" ? unwrapped(context) : unwrapped;
+}
+/**
+* The nearest config walking up from `cwd`. Within one directory a
+* `runset.config.*` file wins over the `package.json` `runset` section.
+*/
+function findConfigJs(cwd) {
+	for (const dir of ancestors(cwd)) {
+		for (const extension of [
+			"ts",
+			"js",
+			"mjs",
+			"cjs",
+			"json"
+		]) {
+			const candidate = path.join(dir, `runset.config.${extension}`);
+			if (fs.existsSync(candidate)) return importSync(candidate);
+		}
+		const section = readPackageJsonSection(path.join(dir, "package.json"));
+		if (section !== void 0) return section;
+	}
+}
+function readPackageJsonSection(filePath) {
+	const runset = readJson(filePath)?.runset;
+	if (runset === void 0) return;
+	if (!isPlainObject(runset)) throw new ConfigError(`${filePath}: "runset" must be an object`);
+	return runset;
+}
+//#endregion
+//#region src/config/winArgv.ts
+/**
+* Windows only: rejoins `'single quoted'` tokens that `cmd.exe` leaves split,
+* joined by single spaces. The identity everywhere else.
+*/
+function regroupQuoted(argv, platform = process.platform) {
+	if (platform !== "win32") return argv;
+	const result = [];
+	let open;
+	for (const token of argv) {
+		if (open === void 0) {
+			if (token.startsWith("'") && token.endsWith("'") && token.length > 1) result.push(token.slice(1, -1));
+			else if (token.startsWith("'")) open = [token.slice(1)];
+			else result.push(token);
+			continue;
+		}
+		if (token.endsWith("'")) {
+			open.push(token.slice(0, -1));
+			result.push(open.join(" "));
+			open = void 0;
+		} else open.push(token);
+	}
+	if (open !== void 0) throw new CliError(`Unterminated quote in "'${open.join(" ")}".`);
+	return result;
+}
+//#endregion
+//#region src/config/parseCli.ts
+const FLAGS = [
+	{
+		name: "parallel",
+		short: "p",
+		takesValue: false
 	},
-	periwinkle: {
-		index: 147,
-		fallback: "blueBright"
+	{
+		name: "serial",
+		short: "s",
+		takesValue: false
 	},
-	peach: {
-		index: 216,
-		fallback: "yellowBright"
+	{
+		name: "recursive",
+		short: "r",
+		takesValue: false
 	},
-	teal: {
-		index: 79,
-		fallback: "cyanBright"
+	{
+		name: "jobs",
+		short: "j",
+		takesValue: true
 	},
-	lilac: {
-		index: 177,
-		fallback: "magentaBright"
+	{
+		name: "killTimeout",
+		takesValue: true
 	},
-	lime: {
-		index: 149,
-		fallback: "greenBright"
+	{
+		name: "onSuccess",
+		takesValue: true
 	},
-	steel: {
-		index: 110,
-		fallback: "blueBright"
+	{
+		name: "onFailure",
+		takesValue: true
 	},
-	pink: {
-		index: 218,
-		fallback: "magentaBright"
+	{
+		name: "config",
+		short: "c",
+		takesValue: true
 	},
-	seafoam: {
-		index: 121,
-		fallback: "cyanBright"
+	{
+		name: "cwd",
+		takesValue: true
 	},
-	apricot: {
-		index: 215,
-		fallback: "yellowBright"
+	{
+		name: "env",
+		short: "e",
+		takesValue: true
 	},
-	mauve: {
-		index: 139,
-		fallback: "magentaBright"
+	{
+		name: "color",
+		negated: "none",
+		takesValue: true
 	},
-	jade: {
-		index: 114,
-		fallback: "greenBright"
+	{
+		name: "logLevel",
+		takesValue: true
 	},
-	sand: {
-		index: 180,
-		fallback: "yellowBright"
-	},
-	iris: {
-		index: 141,
-		fallback: "blueBright"
-	},
-	ice: {
-		index: 117,
-		fallback: "cyanBright"
-	},
-	salmon: {
-		index: 174,
-		fallback: "redBright"
-	},
-	olive: {
-		index: 150,
-		fallback: "greenBright"
-	},
-	navy: {
-		index: 24,
-		fallback: "blue",
-		foreground: "paper"
-	},
-	plum: {
-		index: 96,
-		fallback: "magenta",
-		foreground: "paper"
-	},
-	forest: {
-		index: 22,
-		fallback: "green",
-		foreground: "paper"
-	},
-	wine: {
-		index: 89,
-		fallback: "red",
-		foreground: "paper"
-	},
-	ocean: {
-		index: 25,
-		fallback: "blue",
-		foreground: "paper"
-	},
-	indigo: {
-		index: 61,
-		fallback: "blue",
-		foreground: "paper"
-	},
-	copper: {
-		index: 94,
-		fallback: "red",
-		foreground: "paper"
-	},
-	pine: {
-		index: 23,
-		fallback: "cyan",
-		foreground: "paper"
-	},
-	violet: {
-		index: 55,
-		fallback: "magenta",
-		foreground: "paper"
-	},
-	brick: {
-		index: 88,
-		fallback: "red",
-		foreground: "paper"
-	},
-	slate: {
-		index: 60,
-		fallback: "blue",
-		foreground: "paper"
-	},
-	cocoa: {
-		index: 95,
-		fallback: "red",
-		foreground: "paper"
-	},
-	ink: {
-		index: 235,
-		fallback: "black"
-	},
-	paper: {
-		index: 255,
-		fallback: "whiteBright"
-	}
-};
-/** Every shade by its foreground and its background name, e.g. `mint`, `bgMint`. */
-const SHADE_NAMES = new Map(Object.entries(SHADES).flatMap(([name, custom]) => [[name, custom], [toCamelCase(`bg-${name}`), custom]]));
-const BASIC_PALETTE = [
-	{
-		bgColor: "bgGreen",
-		color: "black"
-	},
-	{
-		bgColor: "bgBlue",
-		color: "white"
+	{
+		name: "dryRun",
+		takesValue: false
 	},
 	{
-		bgColor: "bgMagenta",
-		color: "white"
-	},
-	{
-		bgColor: "bgCyan",
-		color: "black"
+		name: "stdout",
+		takesValue: true
 	},
 	{
-		bgColor: "bgYellow",
-		color: "black"
+		name: "stderr",
+		takesValue: true
 	},
 	{
-		bgColor: "bgRed",
-		color: "white"
+		name: "output",
+		short: "o",
+		takesValue: true
 	},
 	{
-		bgColor: "bgGray",
-		color: "white"
+		name: "labels",
+		takesValue: true
 	},
 	{
-		bgColor: "bgGreenBright",
-		color: "black"
+		name: "showCommand",
+		takesValue: false
 	},
 	{
-		bgColor: "bgBlueBright",
-		color: "black"
+		name: "showExitCode",
+		takesValue: false
 	},
 	{
-		bgColor: "bgMagentaBright",
-		color: "black"
+		name: "wrap",
+		takesValue: false
 	},
 	{
-		bgColor: "bgCyanBright",
-		color: "black"
+		name: "help",
+		short: "h",
+		takesValue: false
 	},
 	{
-		bgColor: "bgYellowBright",
-		color: "black"
+		name: "version",
+		short: "v",
+		takesValue: false
 	}
 ];
-/** Interleave hue families so adjacent assignments remain easy to tell apart. */
-const PALETTE = Object.entries(SHADES).filter(([name]) => name !== "ink" && name !== "paper").map(([name, { foreground }]) => ({
-	bgColor: toCamelCase(`bg-${name}`),
-	color: foreground ?? "ink"
-}));
-/** What `colorLabels` hands out under each mode; `none` still picks, unseen. */
-const PALETTES = {
-	none: BASIC_PALETTE,
-	basic: BASIC_PALETTE,
-	soft: PALETTE.filter((pair) => pair.color === "ink"),
-	all: PALETTE
-};
-/** A built-in style or one of runset's foreground/background shades. */
-function isColorName(name) {
-	return KNOWN.has(name) || shade(name) !== void 0;
-}
-/** Styles text; a shade is painted from the 256-color table. */
-function paint(text, colors) {
-	let result = text;
-	for (const name of colors.toReversed()) {
-		const custom = shade(name);
-		if (custom !== void 0) {
-			const background = name.startsWith("bg");
-			const open = `\u001B[${background ? 48 : 38};5;${custom.index}m`;
-			const close = `\u001B[${background ? 49 : 39}m`;
-			result = open + result.replaceAll(close, open) + close;
-		} else if (KNOWN.has(name)) result = styleText(name, result, { validateStream: false });
-	}
-	return result;
-}
-/** The theme color used for a shade on a basic terminal. */
-function fallbackColor(name) {
-	const custom = shade(name);
-	if (custom === void 0) return name;
-	return name.startsWith("bg") ? toCamelCase(`bg-${custom.fallback}`) : custom.fallback;
-}
-/** A stable palette index for a label. */
-function paletteIndex(label, palette = PALETTE) {
-	/** The largest modulus that keeps `hash * 31 + code` an exact integer. */
-	const HASH_MODULUS = 2147483647;
-	let hash = 0;
-	for (const character of label) hash = (hash * 31 + (character.codePointAt(0) ?? 0)) % HASH_MODULUS;
-	return hash % palette.length;
-}
-function shade(name) {
-	return SHADE_NAMES.get(name);
-}
-//#endregion
-//#region src/plan/stages.ts
-const EMPTY_SEGMENT = {
-	commands: [],
-	parallel: false
-};
-/** A `-p`/`-s`: what follows starts a new group past everything before it. */
-const BOUNDARY = {
-	boundary: true,
-	commands: [],
-	parallel: false
-};
 /**
-* Lays segments out into stages. A parallel segment joins the open stage;
-* anything else starts past every stage in use, and so does what follows it.
-* A segment's commands keep their relative stages, shifted onto its own.
+* Splits argv into options, commands, and the literal arguments after `--`.
+* Each `-p`/`-s` becomes a settings entry where it was typed, the same object
+* a config file would write.
 */
-function link(segments) {
+function parseCli(rawArgv) {
+	const argv = regroupQuoted(rawArgv);
+	const options = {};
 	const commands = [];
-	/** The stage a parallel segment joins. */
-	let open = 0;
-	/** The last stage in use; -1 while none is. */
-	let used = -1;
-	for (const segment of segments) {
-		if (segment.boundary) {
-			open = used + 1;
-			continue;
-		}
-		if (segment.commands.length === 0) continue;
-		const base = segment.parallel ? open : used + 1;
-		for (const command of segment.commands) {
-			command.stage += base;
-			used = Math.max(used, command.stage);
-			commands.push(command);
-		}
-		open = segment.parallel ? open : used + 1;
-	}
-	return commands;
-}
-/** Splits a stage-sorted list into its stages. */
-function groupByStage(items, stageOf) {
-	const stages = [];
-	let current;
-	let stage;
-	for (const item of items) {
-		const own = stageOf(item);
-		if (current === void 0 || own !== stage) {
-			current = [];
-			stage = own;
-			stages.push(current);
+	let positional = [];
+	let help = false;
+	let version = false;
+	let cursor = 0;
+	function setOption(spec, raw) {
+		switch (spec.name) {
+			case "env": {
+				const text = String(raw);
+				const eq = text.indexOf("=");
+				if (eq < 1) throw new CliError(`Option "--env" takes NAME=value, not "${text}".`);
+				(options.env ??= {})[text.slice(0, eq)] = text.slice(eq + 1);
+				break;
+			}
+			case "help":
+				help = true;
+				break;
+			case "jobs":
+			case "killTimeout":
+				options[spec.name] = Number(raw);
+				break;
+			case "parallel":
+			case "serial":
+				commands.push({ parallel: spec.name === "parallel" });
+				break;
+			case "version":
+				version = true;
+				break;
+			default: options[spec.name] = raw;
 		}
-		current.push(item);
 	}
-	return stages;
-}
-//#endregion
-//#region src/plan/labels.ts
-/**
-* Settles who is labelled, per `config.labels`. Under `auto`, a command
-* sharing a stage is named after itself, whether or not someone in its stage
-* has a label of their own. Under `custom` it gets a blank label instead,
-* holding the column when someone in its stage has one.
-*/
-function assignAutoLabels({ commands, config }) {
-	const mode = config.labels;
-	if (mode === "none") {
-		for (const command of commands) command.label = "";
-		return;
+	function takeValue(label) {
+		const value = argv[cursor + 1];
+		if (value === void 0) throw new CliError(`Option "${label}" needs a value.`);
+		cursor += 1;
+		return value;
 	}
-	const named = [];
-	for (const stage of groupByStage(commands, (command) => command.stage)) {
-		const shared = stage.length > 1;
-		const labeled = stage.some((command) => command.label !== "");
-		for (const command of stage) {
-			if (command.label !== "") continue;
-			if (mode === "all" || mode === "auto" && shared) {
-				command.label = nameOf(command);
-				named.push(command);
-			} else if (shared && labeled) command.label = " ";
+	function readLong(body) {
+		const eq = body.indexOf("=");
+		const name = eq === -1 ? body : body.slice(0, eq);
+		const inlineValue = eq === -1 ? void 0 : body.slice(eq + 1);
+		const flag = findLongFlag(name);
+		if (flag === void 0 && /^no-?[A-Za-z]/.test(name)) {
+			const negated = findLongFlag(name.replace(/^no-?/, ""));
+			if (negated && (!negated.takesValue || negated.negated !== void 0)) {
+				setOption(negated, negated.negated ?? false);
+				return;
+			}
 		}
+		if (flag === void 0) throw new CliError(`Unknown option "--${name}".`);
+		if (flag.takesValue) setOption(flag, inlineValue ?? takeValue(`--${name}`));
+		else setOption(flag, true);
 	}
-	numberRepeats(named);
-}
-/**
-* Gives each labelled command without colors of its own a palette pair: the
-* one its label hashes to, or the next free when that is taken, from the
-* palette of `config.color`. Without shades every one is first swapped for its
-* theme color, so nothing past the plan has to know how many colors there are.
-*/
-function colorLabels({ commands, config }) {
-	const palette = PALETTES[config.color];
-	if (config.color === "none" || config.color === "basic") for (const command of commands) {
-		command.bgColor = fallbackColor(command.bgColor);
-		command.color = fallbackColor(command.color);
+	function readShortCluster(body) {
+		for (let position = 0; position < body.length; position += 1) {
+			const letter = body[position];
+			const flag = findShortFlag(letter);
+			if (flag === void 0) throw new CliError(`Unknown option "-${letter}".`);
+			if (!flag.takesValue) {
+				setOption(flag, true);
+				continue;
+			}
+			const rest = body.slice(position + 1);
+			setOption(flag, rest === "" ? takeValue(`-${letter}`) : rest);
+			return;
+		}
 	}
-	const labeled = commands.filter((command) => command.label !== "");
-	const taken = new Set(labeled.map((command) => palette.findIndex((pair) => pair.bgColor === command.bgColor)).filter((index) => index !== -1));
-	for (const command of labeled) {
-		if (command.color !== "" || command.bgColor !== "" || command.label.trim() === "") continue;
-		const index = claim(paletteIndex(command.label, palette), taken, palette.length);
-		taken.add(index);
-		const pair = palette[index];
-		command.bgColor = pair.bgColor;
-		command.color = pair.color;
+	for (; cursor < argv.length; cursor += 1) {
+		const token = argv[cursor];
+		if (token === "--") {
+			positional = argv.slice(cursor + 1);
+			break;
+		}
+		if (token.startsWith("--") && token.length > 2) readLong(token.slice(2));
+		else if (token.startsWith("-") && token.length > 1) readShortCluster(token.slice(1));
+		else commands.push(token);
 	}
+	return {
+		argv,
+		commands,
+		help,
+		options,
+		positional,
+		version
+	};
 }
-/** Pads every label to the widest one. */
-function alignLabels({ commands }) {
-	const labeled = commands.filter((command) => command.label !== "");
-	const width = Math.max(0, ...labeled.map((command) => command.label.length));
-	for (const command of labeled) command.label = command.label.padEnd(width);
-}
-/** The script name, or the program a shell command runs. */
-function nameOf(command) {
-	return command.packageName ?? command.scriptName ?? command.command.split(/\s/, 1)[0] ?? "";
-}
-/** `serve`, `serve` → `serve#1`, `serve#2`. */
-function numberRepeats(named) {
-	const totals = /* @__PURE__ */ new Map();
-	for (const command of named) totals.set(command.label, (totals.get(command.label) ?? 0) + 1);
-	const counters = /* @__PURE__ */ new Map();
-	for (const command of named) {
-		if ((totals.get(command.label) ?? 0) < 2) continue;
-		const index = (counters.get(command.label) ?? 0) + 1;
-		counters.set(command.label, index);
-		command.label = `${command.label}#${index}`;
-	}
+function findLongFlag(name) {
+	const camel = toCamelCase(name);
+	return FLAGS.find((flag) => flag.name === camel);
 }
-function claim(preferred, taken, size) {
-	if (taken.size >= size) return preferred;
-	let index = preferred;
-	while (taken.has(index)) index = (index + 1) % size;
-	return index;
+function findShortFlag(letter) {
+	return FLAGS.find((flag) => flag.short === letter);
 }
 //#endregion
-//#region src/utils/glob.ts
-function isGlob(pattern) {
-	return pattern.includes("*");
-}
-/** The `names` a glob matches, in declared order; none is not an error. */
-function matchGlob(pattern, names) {
-	const regexp = toRegExp(pattern);
-	return names.filter((name) => regexp.test(name));
-}
-function escape(literal) {
-	return literal.replaceAll(/[$()+.?[\\\]^{|}]/g, String.raw`\$&`);
+//#region src/config/Config.ts
+const DEFAULT_KILL_TIMEOUT = 5e3;
+const LOG_LEVELS = /* @__PURE__ */ new Set([
+	"error",
+	"warn",
+	"info",
+	"debug"
+]);
+const LABEL_MODES = /* @__PURE__ */ new Set([
+	"none",
+	"auto",
+	"custom",
+	"all"
+]);
+const COLOR_MODES = /* @__PURE__ */ new Set([
+	"auto",
+	"none",
+	"basic",
+	"soft",
+	"all"
+]);
+/** Every key a config may set; a record, so a new one cannot be missed. */
+const KNOWN_KEYS = {
+	color: true,
+	commands: true,
+	cwd: true,
+	dryRun: true,
+	env: true,
+	formatLabel: true,
+	jobs: true,
+	killTimeout: true,
+	labels: true,
+	logLevel: true,
+	onFailure: true,
+	onSuccess: true,
+	output: true,
+	parallel: true,
+	recursive: true,
+	scripts: true,
+	showCommand: true,
+	showExitCode: true,
+	stderr: true,
+	stdout: true,
+	wrap: true
+};
+/** Parses, loads and validates; anything left out comes from the process. */
+function createConfig({ cli = parseCli(process.argv.slice(2)), configJs, cwd = process.cwd(), destinations = process, env = process.env } = {}) {
+	const config = new Config({
+		cli,
+		configJs,
+		cwd,
+		destinations,
+		env
+	});
+	config.validate();
+	return config;
 }
+/** The resolved run-wide configuration: CLI flag → config file → default. */
+var Config = class {
+	commands;
+	scripts;
+	/** Everything after `--`, for placeholders. */
+	args;
+	cwd;
+	env;
+	jobs;
+	killTimeout;
+	onSuccess;
+	onFailure;
+	color;
+	parallel;
+	recursive;
+	showCommand;
+	showExitCode;
+	wrap;
+	/** `COLUMNS` as runset was started with it: the width where no TTY says. */
+	envColumns;
+	labels;
+	logLevel;
+	dryRun;
+	formatLabel;
+	stdout;
+	stderr;
+	destinations;
+	/** Printed by the run once it is built. */
+	warnings = [];
+	constructor({ cli, configJs, cwd, destinations, env }) {
+		const { options } = cli;
+		this.cwd = path.resolve(cwd, options.cwd ?? ".");
+		this.destinations = destinations;
+		const context = {
+			argv: cli.argv,
+			cwd: this.cwd,
+			env
+		};
+		const file = configJs === void 0 ? loadConfigJs(context, options.config) : unwrapConfigJs(configJs, context);
+		for (const key of Object.keys(file)) if (!Object.hasOwn(KNOWN_KEYS, key)) this.warnings.push(`Unknown config key "${key}" was ignored.`);
+		if (file.cwd !== void 0 && options.cwd === void 0) this.cwd = path.resolve(cwd, file.cwd);
+		check(envError("env", file.env ?? {}), ConfigError);
+		this.env = {
+			...env,
+			...file.env,
+			...options.env
+		};
+		this.commands = [...file.commands ?? [], ...cli.commands].filter(Boolean);
+		this.scripts = file.scripts ?? {};
+		this.args = cli.positional;
+		this.jobs = options.jobs ?? file.jobs ?? Number.POSITIVE_INFINITY;
+		this.killTimeout = options.killTimeout ?? file.killTimeout ?? DEFAULT_KILL_TIMEOUT;
+		this.parallel = file.parallel ?? false;
+		this.recursive = options.recursive ?? file.recursive ?? false;
+		this.showCommand = options.showCommand ?? file.showCommand ?? false;
+		this.showExitCode = options.showExitCode ?? file.showExitCode ?? false;
+		this.wrap = options.wrap ?? file.wrap ?? true;
+		this.envColumns = parseColumns(env.COLUMNS);
+		this.labels = options.labels ?? file.labels ?? "auto";
+		this.onSuccess = options.onSuccess ?? file.onSuccess ?? "continue";
+		this.onFailure = options.onFailure ?? file.onFailure ?? "stop";
+		this.dryRun = options.dryRun ?? file.dryRun ?? false;
+		this.logLevel = options.logLevel ?? file.logLevel ?? "info";
+		this.color = resolveColor(options.color ?? file.color, env, destinations);
+		this.formatLabel = file.formatLabel;
+		const streams = layerStreams({
+			stderr: defaultStd("stderr"),
+			stdout: defaultStd("stdout")
+		}, [file, options]);
+		this.stdout = streams.stdout;
+		this.stderr = streams.stderr;
+	}
+	/** Throws on the first invalid value; types too, as config files are arbitrary JS. */
+	validate() {
+		check([
+			oneOfError("logLevel", this.logLevel, LOG_LEVELS),
+			numberError("jobs", this.jobs, 1),
+			numberError("killTimeout", this.killTimeout, 0),
+			oneOfError("color", this.color, COLOR_MODES),
+			booleanError("parallel", this.parallel),
+			booleanError("recursive", this.recursive),
+			booleanError("showCommand", this.showCommand),
+			booleanError("showExitCode", this.showExitCode),
+			booleanError("wrap", this.wrap),
+			booleanError("dryRun", this.dryRun),
+			oneOfError("labels", this.labels, LABEL_MODES),
+			stdError("stdout", this.stdout),
+			stdError("stderr", this.stderr),
+			this.formatLabel !== void 0 && typeof this.formatLabel !== "function" ? "formatLabel must be a function." : void 0,
+			isPlainObject(this.scripts) ? void 0 : "scripts must be an object.",
+			actionError("onSuccess", this.onSuccess),
+			actionError("onFailure", this.onFailure)
+		].find((error) => error !== void 0), ConfigError);
+	}
+	/** True when `commands` holds something to run, not just settings entries. */
+	hasCommands() {
+		return this.commands.some((command) => Boolean(command) && !isSettingsEntry(command));
+	}
+};
 /**
-* `*` matches within one `:`-separated segment, `**` spans one or more.
-* `build:**:*` means `build:**`.
+* A mode as given; under `auto`, whether to color at all, then `soft` where
+* the terminal shows 256 colors. `all` is only ever asked for. Anything else is
+* left for `validate` to refuse.
 */
-function toRegExp(pattern) {
-	const segments = pattern.split(":");
-	const source = [];
-	for (const [index, segment] of segments.entries()) {
-		if (segment === "*" && segments[index - 1] === "**") continue;
-		if (segment === "**") source.push(String.raw`[^:]+(?::[^:]+)*`);
-		else source.push(segment.split("*").map((part) => escape(part)).join("[^:]*"));
-	}
-	return new RegExp(`^${source.join(":")}$`);
-}
-//#endregion
-//#region src/utils/workspace.ts
-/**
-* The packages of the workspace at or above `cwd`, from `pnpm-workspace.yaml`
-* or `package.json` `workspaces`, sorted by path; the root is not one of them.
-*/
-function readWorkspacePackages(cwd) {
-	for (const dir of ancestors(cwd)) {
-		const patterns = readWorkspacePatterns(dir);
-		if (patterns === void 0) continue;
-		const include = patterns.filter((pattern) => !pattern.startsWith("!"));
-		const exclude = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
-		return fs.globSync(include, {
-			cwd: dir,
-			exclude: [...exclude, "**/node_modules"]
-		}).map((match) => path.join(dir, match, "package.json")).filter((filePath) => fs.existsSync(filePath)).toSorted().map((filePath) => readPackageJson(path.dirname(filePath)));
-	}
-	return [];
-}
-function readWorkspacePatterns(dir) {
-	const yamlPath = path.join(dir, "pnpm-workspace.yaml");
-	if (fs.existsSync(yamlPath)) return parsePnpmPackages(fs.readFileSync(yamlPath, "utf8"));
-	const jsonPath = path.join(dir, "package.json");
-	if (!fs.existsSync(jsonPath)) return;
-	const { workspaces } = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
-	return Array.isArray(workspaces) ? workspaces : workspaces?.packages;
-}
-/** The `packages:` list of a `pnpm-workspace.yaml`, read without a YAML parser. */
-function parsePnpmPackages(text) {
-	const patterns = [];
-	let inPackages = false;
-	for (const raw of text.split(/\r?\n/)) {
-		const line = raw.replace(/\s#.*$/, "").trimEnd();
-		if (/^\S/.test(line)) inPackages = /^packages\s*:/.test(line);
-		else if (inPackages && /^\s+-/.test(line)) patterns.push(line.replace(/^\s+-\s*/, "").replaceAll(/^['"]|['"]$/g, ""));
-	}
-	return patterns;
-}
-//#endregion
-//#region src/utils/os.ts
-/** 128 + the signal's number, the way a shell reports it: 130, 143, … */
-function signalExitCode(signal) {
-	return 128 + (os.constants.signals[signal] ?? 15);
-}
-/**
-* Quotes a value so the platform's shell passes it on as literal text —
-* double quotes are not enough, since `$(…)` still runs inside them.
-*/
-function quoteForShell(value, platform = process.platform) {
-	return platform === "win32" ? quoteForCmd(value) : quoteForPosix(value);
-}
-/** Single quotes are fully literal; each `'` inside closes, escapes, reopens. */
-function quoteForPosix(value) {
-	return `'${value.replaceAll("'", String.raw`'\''`)}'`;
-}
-/**
-* Quoted for the C runtime first, then every `cmd.exe` metacharacter
-* `^`-escaped (see <https://qntm.org/cmd>). Newlines cannot survive `cmd.exe`,
-* so they become spaces.
-*/
-function quoteForCmd(value) {
-	return `"${value.replaceAll("\r\n", " ").replaceAll(/[\n\r]/g, " ").replaceAll(/(\\*)"/g, String.raw`$1$1\"`).replace(/(\\*)$/, "$1$1")}"`.replaceAll(/["%&()<>^|]/g, (character) => `^${character}`);
-}
-//#endregion
-//#region src/plan/placeholders.ts
-/**
-* Fills `{1}`, `{@}`, `{*}` and `{name}` from the arguments after `--`.
-*
-* In a command line values are shell-quoted and unknown names left as written
-* (`${HOME}`); in an option (`forOption`) values are raw and unknown names
-* are empty, so `disabled={noTest}` is false when nothing was passed.
-*/
-function substitutePlaceholders(text, args, forOption = false) {
-	const PLACEHOLDER = /\{([^\s{}]*)\}/g;
-	const wrap = forOption ? (value) => value : quoteForShell;
-	return text.replaceAll(PLACEHOLDER, (match, key) => {
-		if (key === "@") return args.map((arg) => wrap(arg)).join(" ");
-		if (key === "*") return args.length === 0 ? "" : wrap(args.join(" "));
-		if (/^[1-9]\d*$/.test(key)) {
-			const value = args[Number(key) - 1];
-			return value === void 0 ? "" : wrap(value);
-		}
-		const named = namedValue(key, args);
-		if (named !== void 0) return wrap(named);
-		return forOption ? "" : match;
-	});
-}
-/**
-* The value of `--name=value` or `--name value` (camel or kebab); a bare
-* `--name` is `'true'`.
-*/
-function namedValue(key, args) {
-	for (const [index, token] of args.entries()) {
-		if (!token.startsWith("--") || token.length === 2) continue;
-		const equals = token.indexOf("=");
-		if (toCamelCase(equals === -1 ? token.slice(2) : token.slice(2, equals)) !== key) continue;
-		if (equals !== -1) return token.slice(equals + 1);
-		const next = args[index + 1];
-		return next !== void 0 && !next.startsWith("-") ? next : "true";
-	}
-}
-//#endregion
-//#region src/plan/token.ts
-const BOOLEAN_OPTIONS = /* @__PURE__ */ new Set([
-	"disabled",
-	"parallel",
-	"recursive"
-]);
-const ACTION_OPTIONS = /* @__PURE__ */ new Set(["onFailure", "onSuccess"]);
-/** Keys a `::` suffix may set. */
-const INLINE_OPTIONS = /* @__PURE__ */ new Set([
-	"bgColor",
-	"color",
-	"cwd",
-	"label",
-	"output",
-	"stderr",
-	"stdout",
-	...BOOLEAN_OPTIONS,
-	...ACTION_OPTIONS
-]);
-/**
-* Splits `"name args::options"` at the last `::`. The options run to the end
-* of the string, so a trailing space stays part of the last value.
-*/
-function splitToken(raw) {
-	const trimmed = raw.trimStart();
-	const marker = trimmed.lastIndexOf("::");
-	const command = (marker === -1 ? trimmed : trimmed.slice(0, marker)).trim();
-	const space = command.search(/\s/);
-	return {
-		args: space === -1 ? "" : command.slice(space + 1).trim(),
-		name: space === -1 ? command : command.slice(0, space),
-		options: marker === -1 ? "" : trimmed.slice(marker + 2)
-	};
+function resolveColor(mode, env, destinations) {
+	if (mode !== void 0 && mode !== "auto") return mode;
+	if (!detectColor(env, destinations)) return "none";
+	return WriteStream.prototype.getColorDepth(env) >= 8 ? "soft" : "basic";
 }
-/**
-* Parses `key=value,flag`. Split before placeholders are filled, so a `,` or
-* `=` arriving in a value cannot inject another option.
-*/
-function parseInlineOptions(text, args) {
-	const options = {};
-	for (const entry of text.split(",")) {
-		if (entry.trim() === "") continue;
-		const eq = entry.indexOf("=");
-		const key = toCamelCase((eq === -1 ? entry : entry.slice(0, eq)).trim());
-		const written = eq === -1 ? "true" : entry.slice(eq + 1);
-		const value = substitutePlaceholders(key === "label" ? written : written.trim(), args, true);
-		if (!INLINE_OPTIONS.has(key)) throw new NormalizeError(`Unknown command option "${toKebabCase(key)}" in "::${text.trim()}".`);
-		if (key === "output" || key === "stderr" || key === "stdout") options[key] = parsePartialStd(value);
-		else if (BOOLEAN_OPTIONS.has(key)) options[key] = value !== "false" && value !== "";
-		else if (ACTION_OPTIONS.has(key)) {
-			check(actionError(`"${toKebabCase(key)}"`, value), NormalizeError);
-			options[key] = value;
-		} else options[key] = value;
-	}
-	return options;
+/** `NO_COLOR`/`FORCE_COLOR`, then whether both streams are TTYs. */
+function detectColor(env, destinations) {
+	if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+	if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+	return isTerminal(destinations.stdout) && isTerminal(destinations.stderr);
 }
 //#endregion
-//#region src/plan/normalize.ts
-/** Keys a settings entry may set. */
-const SETTINGS_OPTIONS = /* @__PURE__ */ new Set([
-	...INLINE_OPTIONS,
-	"env",
-	"serial"
-]);
-/**
-* Turns `config.commands` into the run's commands: flat, validated, numbered
-* by stage and sorted by it.
-*/
-function normalize(config, packageInfo) {
-	const scriptNames = Object.keys(packageInfo.scripts);
-	let workspacePackages;
-	const defaults = {
-		bgColor: "",
-		color: "",
-		command: "",
-		cwd: config.cwd,
-		disabled: false,
-		env: {},
-		label: "",
-		line: "",
-		onFailure: config.onFailure,
-		onSuccess: config.onSuccess,
-		parallel: config.parallel,
-		recursive: config.recursive,
-		stage: 0,
-		stderr: config.stderr,
-		stdout: config.stdout,
-		type: "shell"
-	};
-	function makeLeaf(token, rawOptions, script, pkg = packageInfo) {
-		const options = {
-			...rawOptions,
-			stderr: mergeStd(defaults.stderr, rawOptions.stderr),
-			stdout: mergeStd(defaults.stdout, rawOptions.stdout)
-		};
-		const args = substitutePlaceholders(token.args, config.args);
-		const command = [token.name, args].filter((part) => part !== "").join(" ");
-		const line = script === void 0 ? command : [pkg.scripts[script], args].filter((part) => part !== "").join(" ");
-		const leaf = {
-			...defaults,
-			...options,
-			command,
-			line,
-			stage: 0,
-			type: script === void 0 ? "shell" : "npm",
-			...script === void 0 ? {} : { scriptName: script },
-			...pkg === packageInfo ? {} : { packageName: packageNameOf(pkg) }
-		};
-		if (script !== void 0 && options.cwd === void 0) leaf.cwd = pkg.filePath === "" ? config.cwd : path.dirname(pkg.filePath);
-		validateCommand(leaf);
-		return leaf;
-	}
-	/** Links one token's commands (e.g. glob matches) by their own `parallel`. */
-	function toSegment(leaves, settled) {
-		return {
-			commands: link(leaves.filter((leaf) => !leaf.disabled).map((leaf) => ({
-				commands: [leaf],
-				parallel: leaf.parallel
-			}))),
-			parallel: settled.parallel ?? defaults.parallel
-		};
-	}
-	function resolveToken(raw, inherited, overrides, seen) {
-		const token = splitToken(raw);
-		const inline = resolveCwd(parseInlineOptions(token.options, config.args), inherited.cwd ?? config.cwd);
-		if (Object.hasOwn(config.scripts, token.name)) {
-			if (seen.has(token.name)) throw new NormalizeError(`Command "${token.name}" refers to itself.`);
-			const resolved = resolveEntry(config.scripts[token.name], inherited, layer(inline, overrides), /* @__PURE__ */ new Set([...seen, token.name]));
-			return token.args === "" ? resolved : appendArgs(resolved, token);
-		}
-		const settled = layer(inherited, inline, overrides);
-		if (settled.recursive ?? defaults.recursive) {
-			workspacePackages ??= readWorkspacePackages(config.cwd);
-			const leaves = workspacePackages.flatMap((pkg) => matchScripts(token.name, pkg).map((name) => makeLeaf({
-				...token,
-				name
-			}, settled, name, pkg)));
-			if (leaves.length > 0) return toSegment(leaves, settled);
-		}
-		if (isGlob(token.name)) return toSegment(matchGlob(token.name, scriptNames).map((name) => makeLeaf({
-			...token,
-			name
-		}, settled, name)), settled);
-		return toSegment([makeLeaf(token, settled, Object.hasOwn(packageInfo.scripts, token.name) ? token.name : void 0)], settled);
-	}
-	function appendArgs(segment, token) {
-		const [leaf] = segment.commands;
-		if (segment.commands.length !== 1 || leaf === void 0) throw new NormalizeError(`Cannot pass arguments to "${token.name}": it expands to more than one command.`);
-		const args = substitutePlaceholders(token.args, config.args);
-		const extended = {
-			...leaf,
-			command: `${leaf.command} ${args}`,
-			line: `${leaf.line} ${args}`
-		};
-		return {
-			...segment,
-			commands: [extended]
-		};
-	}
-	/** One list entry other than a settings entry. */
-	function resolve(definition, inherited, overrides, seen) {
-		if (!definition) return EMPTY_SEGMENT;
-		if (typeof definition === "string") return resolveToken(definition, inherited, overrides, seen);
-		if (Array.isArray(definition)) throw new NormalizeError("A list of commands belongs in \"commands\" or in a \"scripts\" entry, not inside one.");
-		if (isCommandSettings(definition)) throw new NormalizeError("A command definition needs a \"command\" field.");
-		const entry = definition;
-		if (typeof entry.command !== "string") throw new NormalizeError("A command's \"command\" must be a string.");
-		const { command, ...raw } = entry;
-		return resolveToken(command, layer(inherited, resolveCwd(raw, inherited.cwd ?? config.cwd)), overrides, seen);
-	}
-	/**
-	* `commands`, or a `scripts` entry that is a list. The list's own
-	* `parallel` places the list as a whole and is not passed to its members.
-	*/
-	function resolveList(definitions, inherited, overrides, seen) {
-		const { parallel: inheritedParallel, ...passedDown } = inherited;
-		const { parallel: overriddenParallel, ...passedOver } = overrides;
-		const parallel = overriddenParallel ?? inheritedParallel ?? defaults.parallel;
-		check(booleanError("\"parallel\" on a list of commands", parallel), NormalizeError);
-		const segments = [];
-		let settled = passedDown;
-		for (const definition of definitions) {
-			if (isSettingsEntry(definition)) {
-				const written = readSettings(definition, settled.cwd ?? config.cwd);
-				settled = layer(settled, written);
-				if (written.parallel !== void 0) segments.push(BOUNDARY);
-				continue;
-			}
-			segments.push(resolve(definition, settled, passedOver, seen));
-		}
-		return {
-			commands: link(segments),
-			parallel
-		};
+//#region src/utils/colors.ts
+const KNOWN = new Set(Object.keys(inspect.colors));
+const SHADES = {
+	mint: {
+		index: 115,
+		fallback: "greenBright"
+	},
+	sky: {
+		index: 111,
+		fallback: "blueBright"
+	},
+	rose: {
+		index: 211,
+		fallback: "magentaBright"
+	},
+	amber: {
+		index: 179,
+		fallback: "yellowBright"
+	},
+	lavender: {
+		index: 183,
+		fallback: "magentaBright"
+	},
+	aqua: {
+		index: 80,
+		fallback: "cyanBright"
+	},
+	coral: {
+		index: 210,
+		fallback: "redBright"
+	},
+	sage: {
+		index: 151,
+		fallback: "greenBright"
+	},
+	periwinkle: {
+		index: 147,
+		fallback: "blueBright"
+	},
+	peach: {
+		index: 216,
+		fallback: "yellowBright"
+	},
+	teal: {
+		index: 79,
+		fallback: "cyanBright"
+	},
+	lilac: {
+		index: 177,
+		fallback: "magentaBright"
+	},
+	lime: {
+		index: 149,
+		fallback: "greenBright"
+	},
+	steel: {
+		index: 110,
+		fallback: "blueBright"
+	},
+	pink: {
+		index: 218,
+		fallback: "magentaBright"
+	},
+	seafoam: {
+		index: 121,
+		fallback: "cyanBright"
+	},
+	apricot: {
+		index: 215,
+		fallback: "yellowBright"
+	},
+	mauve: {
+		index: 139,
+		fallback: "magentaBright"
+	},
+	jade: {
+		index: 114,
+		fallback: "greenBright"
+	},
+	sand: {
+		index: 180,
+		fallback: "yellowBright"
+	},
+	iris: {
+		index: 141,
+		fallback: "blueBright"
+	},
+	ice: {
+		index: 117,
+		fallback: "cyanBright"
+	},
+	salmon: {
+		index: 174,
+		fallback: "redBright"
+	},
+	olive: {
+		index: 150,
+		fallback: "greenBright"
+	},
+	navy: {
+		index: 24,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	plum: {
+		index: 96,
+		fallback: "magenta",
+		foreground: "paper"
+	},
+	forest: {
+		index: 22,
+		fallback: "green",
+		foreground: "paper"
+	},
+	wine: {
+		index: 89,
+		fallback: "red",
+		foreground: "paper"
+	},
+	ocean: {
+		index: 25,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	indigo: {
+		index: 61,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	copper: {
+		index: 94,
+		fallback: "red",
+		foreground: "paper"
+	},
+	pine: {
+		index: 23,
+		fallback: "cyan",
+		foreground: "paper"
+	},
+	violet: {
+		index: 55,
+		fallback: "magenta",
+		foreground: "paper"
+	},
+	brick: {
+		index: 88,
+		fallback: "red",
+		foreground: "paper"
+	},
+	slate: {
+		index: 60,
+		fallback: "blue",
+		foreground: "paper"
+	},
+	cocoa: {
+		index: 95,
+		fallback: "red",
+		foreground: "paper"
+	},
+	ink: {
+		index: 235,
+		fallback: "black"
+	},
+	paper: {
+		index: 255,
+		fallback: "whiteBright"
 	}
-	function resolveEntry(entry, inherited, overrides, seen) {
-		return Array.isArray(entry) ? resolveList(entry, inherited, overrides, seen) : resolve(entry, inherited, overrides, seen);
+};
+/** Every shade by its foreground and its background name, e.g. `mint`, `bgMint`. */
+const SHADE_NAMES = new Map(Object.entries(SHADES).flatMap(([name, custom]) => [[name, custom], [toCamelCase(`bg-${name}`), custom]]));
+const BASIC_PALETTE = [
+	{
+		bgColor: "bgGreen",
+		color: "black"
+	},
+	{
+		bgColor: "bgBlue",
+		color: "white"
+	},
+	{
+		bgColor: "bgMagenta",
+		color: "white"
+	},
+	{
+		bgColor: "bgCyan",
+		color: "black"
+	},
+	{
+		bgColor: "bgYellow",
+		color: "black"
+	},
+	{
+		bgColor: "bgRed",
+		color: "white"
+	},
+	{
+		bgColor: "bgGray",
+		color: "white"
+	},
+	{
+		bgColor: "bgGreenBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgBlueBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgMagentaBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgCyanBright",
+		color: "black"
+	},
+	{
+		bgColor: "bgYellowBright",
+		color: "black"
 	}
-	const { commands } = resolveList(config.commands, {}, {}, /* @__PURE__ */ new Set());
-	commands.sort((first, second) => first.stage - second.stage);
-	return commands;
+];
+/** Interleave hue families so adjacent assignments remain easy to tell apart. */
+const PALETTE = Object.entries(SHADES).filter(([name]) => name !== "ink" && name !== "paper").map(([name, { foreground }]) => ({
+	bgColor: toCamelCase(`bg-${name}`),
+	color: foreground ?? "ink"
+}));
+/** What `colorLabels` hands out under each mode; `none` still picks, unseen. */
+const PALETTES = {
+	none: BASIC_PALETTE,
+	basic: BASIC_PALETTE,
+	soft: PALETTE.filter((pair) => pair.color === "ink"),
+	all: PALETTE
+};
+/** A built-in style or one of runset's foreground/background shades. */
+function isColorName(name) {
+	return KNOWN.has(name) || shade(name) !== void 0;
 }
-/** The scripts of `pkg` a token name matches, glob or not. */
-function matchScripts(name, pkg) {
-	const scriptNames = Object.keys(pkg.scripts);
-	if (isGlob(name)) return matchGlob(name, scriptNames);
-	return Object.hasOwn(pkg.scripts, name) ? [name] : [];
+/**
+* Styles text; a shade is painted from the 256-color table. Plain text when
+* not `enabled`.
+*/
+function paint(text, colors, enabled = true) {
+	if (!enabled) return text;
+	let result = text;
+	for (const name of colors.toReversed()) {
+		const custom = shade(name);
+		if (custom !== void 0) {
+			const background = name.startsWith("bg");
+			const open = `\u001B[${background ? 48 : 38};5;${custom.index}m`;
+			const close = `\u001B[${background ? 49 : 39}m`;
+			result = open + result.replaceAll(close, open) + close;
+		} else if (KNOWN.has(name)) result = styleText(name, result, { validateStream: false });
+	}
+	return result;
 }
-function packageNameOf(pkg) {
-	return pkg.name || path.basename(path.dirname(pkg.filePath));
+/** The theme color used for a shade on a basic terminal. */
+function fallbackColor(name) {
+	const custom = shade(name);
+	if (custom === void 0) return name;
+	return name.startsWith("bg") ? toCamelCase(`bg-${custom.fallback}`) : custom.fallback;
 }
-function isSettingsEntry(definition) {
-	return typeof definition === "object" && definition !== null && !Array.isArray(definition) && isCommandSettings(definition);
+/** A stable palette index for a label. */
+function paletteIndex(label, palette = PALETTE) {
+	/** The largest modulus that keeps `hash * 31 + code` an exact integer. */
+	const HASH_MODULUS = 2147483647;
+	let hash = 0;
+	for (const character of label) hash = (hash * 31 + (character.codePointAt(0) ?? 0)) % HASH_MODULUS;
+	return hash % palette.length;
 }
-/** Resolves a relative `cwd` against the inherited one, so directories nest. */
-function resolveCwd(options, base) {
-	return options.cwd === void 0 ? options : {
-		...options,
-		cwd: path.resolve(base, options.cwd)
-	};
+function shade(name) {
+	return SHADE_NAMES.get(name);
 }
+//#endregion
+//#region src/plan/labels.ts
 /**
-* Reads a settings entry into the options the rest of its list inherits.
-* Keys are checked strictly: `{ paralel: true }` would otherwise do nothing.
+* Settles who is labelled, per `config.labels`. Under `auto`, a command
+* sharing a stage is named after itself, whether or not someone in its stage
+* has a label of their own. Under `custom` it gets a blank label instead,
+* holding the column when someone in its stage has one.
 */
-function readSettings(entry, base) {
-	const keys = Object.keys(entry);
-	if (keys.length === 0) throw new NormalizeError("A settings entry must set at least one option.");
-	for (const key of keys) if (!SETTINGS_OPTIONS.has(key)) throw new NormalizeError(`Unknown option "${toKebabCase(key)}" in a settings entry.`);
-	const { serial, ...options } = entry;
-	if (serial !== void 0) {
-		check(booleanError("\"serial\"", serial), NormalizeError);
-		if (options.parallel !== void 0) throw new NormalizeError("A settings entry takes \"parallel\" or \"serial\", not both.");
-		options.parallel = !serial;
+function assignAutoLabels({ commands, config }) {
+	const mode = config.labels;
+	if (mode === "none") {
+		for (const command of commands) command.label = "";
+		return;
 	}
-	return resolveCwd(options, base);
+	const named = [];
+	for (const stage of groupByStage(commands, (command) => command.stage)) {
+		const shared = stage.length > 1;
+		const labeled = stage.some((command) => command.label !== "");
+		for (const command of stage) {
+			if (command.label !== "") continue;
+			if (mode === "all" || mode === "auto" && shared) {
+				command.label = nameOf(command);
+				named.push(command);
+			} else if (shared && labeled) command.label = " ";
+		}
+	}
+	numberRepeats(named);
 }
-/** Layers option bags, later over earlier; stream settings merge per axis. */
-function layer(...bags) {
-	const result = {};
-	for (const { output, stderr, stdout, ...rest } of bags) {
-		Object.assign(result, rest);
-		for (const [key, own] of [["stderr", stderr], ["stdout", stdout]]) for (const value of [output, own]) if (value !== void 0) result[key] = mergeStd(toPartialStd(result[key] ?? {}), value);
+/**
+* Gives each labelled command without colors of its own a palette pair: the
+* one its label hashes to, or the next free when that is taken, from the
+* palette of `config.color`. Without shades every one is first swapped for its
+* theme color, so nothing past the plan has to know how many colors there are.
+*/
+function colorLabels({ commands, config }) {
+	const palette = PALETTES[config.color];
+	if (config.color === "none" || config.color === "basic") for (const command of commands) {
+		command.bgColor = fallbackColor(command.bgColor);
+		command.color = fallbackColor(command.color);
+	}
+	const labeled = commands.filter((command) => command.label !== "");
+	const taken = new Set(labeled.map((command) => palette.findIndex((pair) => pair.bgColor === command.bgColor)).filter((index) => index !== -1));
+	for (const command of labeled) {
+		if (command.color !== "" || command.bgColor !== "" || command.label.trim() === "") continue;
+		const index = claim(paletteIndex(command.label, palette), taken, palette.length);
+		taken.add(index);
+		const pair = palette[index];
+		command.bgColor = pair.bgColor;
+		command.color = pair.color;
 	}
-	return result;
 }
-/** Checks what a config file could have written by hand. */
-function validateCommand(command) {
-	const where = (key) => `"${toKebabCase(key)}" on "${command.command}"`;
-	check([
-		...["onFailure", "onSuccess"].map((key) => actionError(where(key), command[key])),
-		...[
-			"disabled",
-			"parallel",
-			"recursive"
-		].map((key) => booleanError(where(key), command[key])),
-		...[
-			"bgColor",
-			"color",
-			"cwd",
-			"label"
-		].map((key) => stringError(where(key), command[key])),
-		...["stderr", "stdout"].map((key) => stdError(where(key), command[key])),
-		envError(where("env"), command.env)
-	].find((error) => error !== void 0), NormalizeError);
+/** Pads every label to the widest one. */
+function alignLabels({ commands }) {
+	const labeled = commands.filter((command) => command.label !== "");
+	const width = Math.max(0, ...labeled.map((command) => command.label.length));
+	for (const command of labeled) command.label = command.label.padEnd(width);
+}
+/** The script name, or the program a shell command runs. */
+function nameOf(command) {
+	return command.packageName ?? command.scriptName ?? command.command.split(/\s/, 1)[0] ?? "";
+}
+/** `serve`, `serve` → `serve#1`, `serve#2`. */
+function numberRepeats(named) {
+	const totals = /* @__PURE__ */ new Map();
+	for (const command of named) totals.set(command.label, (totals.get(command.label) ?? 0) + 1);
+	const counters = /* @__PURE__ */ new Map();
+	for (const command of named) {
+		if ((totals.get(command.label) ?? 0) < 2) continue;
+		const index = (counters.get(command.label) ?? 0) + 1;
+		counters.set(command.label, index);
+		command.label = `${command.label}#${index}`;
+	}
+}
+function claim(preferred, taken, size) {
+	if (taken.size >= size) return preferred;
+	let index = preferred;
+	while (taken.has(index)) index = (index + 1) % size;
+	return index;
 }
 //#endregion
 //#region src/plan/plan.ts
@@ -1602,13 +1601,11 @@ var FileRegistry = class {
 	error;
 	streams = /* @__PURE__ */ new Map();
 	cwd;
-	handler;
-	constructor(cwd) {
+	onFailure;
+	/** `onFailure` is called once, with the first failure. */
+	constructor(cwd, onFailure) {
 		this.cwd = cwd;
-	}
-	/** Called once, with the first failure. */
-	onFailure(handler) {
-		this.handler = handler;
+		this.onFailure = onFailure;
 	}
 	open(destination) {
 		const filePath = path.resolve(this.cwd, destination);
@@ -1626,12 +1623,12 @@ var FileRegistry = class {
 	async closeAll() {
 		const streams = [...this.streams.values()];
 		this.streams.clear();
-		await Promise.all(streams.map(async (stream) => closed(stream)));
+		await Promise.all(streams.map((stream) => closed(stream)));
 	}
 	fail(destination, error) {
 		if (this.error !== void 0) return;
 		this.error = /* @__PURE__ */ new Error(`cannot write to "${destination}": ${error.message}`);
-		this.handler?.(this.error);
+		this.onFailure(this.error);
 	}
 };
 function closed(stream) {
@@ -1679,8 +1676,7 @@ var Logger = class {
 	}
 	write(level, message) {
 		if (RANK[level] > RANK[this.level]) return;
-		const text = this.color ? paint(message, COLORS[level]) : message;
-		this.stream.write(`${text}\n`);
+		this.stream.write(`${paint(message, COLORS[level], this.color)}\n`);
 	}
 };
 //#endregion
@@ -1721,17 +1717,28 @@ function createEnv({ base, cwd, packageInfo, scriptName }) {
 	const PATH_KEY = process.platform === "win32" ? "Path" : "PATH";
 	const pathKey = Object.keys(base).find((key) => key.toUpperCase() === "PATH") ?? PATH_KEY;
 	const binDirs = ancestors(cwd).map((dir) => path.join(dir, "node_modules", ".bin"));
-	const env = {
-		...base,
-		[pathKey]: [...binDirs, base[pathKey]].filter(Boolean).join(path.delimiter)
-	};
-	if (packageInfo.name !== "") env.npm_package_name = packageInfo.name;
-	if (packageInfo.version !== "") env.npm_package_version = packageInfo.version;
+	const own = {};
+	if (packageInfo.name !== "") own.npm_package_name = packageInfo.name;
+	if (packageInfo.version !== "") own.npm_package_version = packageInfo.version;
 	if (scriptName !== void 0) {
-		env.npm_lifecycle_event = scriptName;
-		env.npm_lifecycle_script = packageInfo.scripts[scriptName] ?? "";
+		own.npm_lifecycle_event = scriptName;
+		own.npm_lifecycle_script = packageInfo.scripts[scriptName] ?? "";
 	}
-	return env;
+	return {
+		...withoutSpellingsOf(base, Object.keys(own)),
+		...own,
+		[pathKey]: [...binDirs, base[pathKey]].filter(Boolean).join(path.delimiter)
+	};
+}
+/**
+* Windows names are case-insensitive, and of two spellings a child is given
+* the one that sorts first — an outer npm's `NPM_…` over ours — so on Windows
+* every other spelling of a name about to be set is dropped.
+*/
+function withoutSpellingsOf(env, names) {
+	if (process.platform !== "win32") return env;
+	const replaced = new Set(names.map((name) => name.toUpperCase()));
+	return Object.fromEntries(Object.entries(env).filter(([key]) => !replaced.has(key.toUpperCase())));
 }
 //#endregion
 //#region src/run/OutputSink.ts
@@ -1740,31 +1747,26 @@ function createEnv({ base, cwd, packageInfo, scriptName }) {
 * `grouped` holds everything until {@link flush}, `none` discards.
 */
 var OutputSink = class {
+	/** A grouped stream's output, or a prefixed stream's unfinished line. */
 	buffered = "";
-	/** A prefixed stream's unfinished line, held until its newline. */
-	pending = "";
 	opened;
 	/** Whether everything written so far ended with a newline. */
 	atLineStart = true;
 	std;
 	prefix;
-	destinations;
-	files;
-	wrap;
-	/** `COLUMNS`, for a stream that is not a terminal. */
-	envColumns;
-	constructor(std, prefix, destinations, files, wrap = false, envColumns) {
+	/** The columns a fixed prefix takes; measured per line otherwise. */
+	prefixWidth;
+	context;
+	constructor(std, prefix, context) {
 		this.std = std;
 		this.prefix = prefix;
-		this.destinations = destinations;
-		this.files = files;
-		this.wrap = wrap;
-		this.envColumns = envColumns;
+		this.prefixWidth = typeof prefix === "string" ? visibleWidth(prefix) : void 0;
+		this.context = context;
 	}
 	/** Opened on first use, so a command that never writes truncates nothing. */
 	get target() {
-		if (isStreamDestination(this.std.destination)) return this.destinations[this.std.destination];
-		this.opened ??= this.files.open(this.std.destination);
+		if (isStreamDestination(this.std.destination)) return this.context.config.destinations[this.std.destination];
+		this.opened ??= this.context.files.open(this.std.destination);
 		return this.opened;
 	}
 	/**
@@ -1772,8 +1774,9 @@ var OutputSink = class {
 	* else `COLUMNS`. A file has none, and neither has a run without `wrap`.
 	*/
 	columns() {
-		if (!this.wrap || !isStreamDestination(this.std.destination)) return;
-		return terminalColumns(this.target) ?? this.envColumns;
+		const { envColumns, wrap } = this.context.config;
+		if (!wrap || !isStreamDestination(this.std.destination)) return;
+		return terminalColumns(this.target) ?? envColumns;
 	}
 	write(chunk) {
 		if (this.std.destination === "none" || chunk === "") return;
@@ -1786,11 +1789,13 @@ var OutputSink = class {
 			this.target.write(chunk);
 			return;
 		}
-		this.pending += chunk;
-		const end = this.pending.lastIndexOf("\n");
-		if (end === -1) return;
-		const complete = this.pending.slice(0, end + 1);
-		this.pending = this.pending.slice(end + 1);
+		const end = chunk.lastIndexOf("\n");
+		if (end === -1) {
+			this.buffered += chunk;
+			return;
+		}
+		const complete = this.buffered + chunk.slice(0, end + 1);
+		this.buffered = chunk.slice(end + 1);
 		this.target.write(this.applyPrefix(complete));
 	}
 	/** A line of runset's own, on a line of its own: after any unfinished one. */
@@ -1799,27 +1804,32 @@ var OutputSink = class {
 	}
 	/** Emits what is held back: a `grouped` stream, or a partial line. */
 	flush() {
-		const held = [this.pending, this.buffered].filter((text) => text !== "");
-		this.pending = "";
+		const held = this.buffered;
 		this.buffered = "";
-		for (const text of held) this.target.write(this.applyPrefix(text));
+		if (held !== "") this.target.write(this.applyPrefix(held));
 	}
 	applyPrefix(chunk) {
 		const { prefix } = this;
 		if (prefix === "") return chunk;
 		const endsWithNewline = chunk.endsWith("\n");
 		const body = endsWithNewline ? chunk.slice(0, -1) : chunk;
+		const end = endsWithNewline ? "\n" : "";
 		const columns = this.columns();
-		return body.split("\n").map((line) => this.label(line, prefix, columns)).join("\n") + (endsWithNewline ? "\n" : "");
+		if (typeof prefix === "string" && columns === void 0) return prefix + body.replaceAll("\n", `\n${prefix}`) + end;
+		return body.split("\n").map((line) => this.label(line, prefix, columns)).join("\n") + end;
 	}
 	/** One line, prefixed; wrapped first when it would overflow the terminal. */
 	label(line, prefix, columns) {
 		const text = typeof prefix === "string" ? prefix : prefix();
 		if (columns === void 0) return text + line;
-		const width = visibleWidth(text);
-		return wrapLine(line, columns - width, width).map((piece) => text + piece).join("\n");
+		const cr = line.endsWith("\r") ? "\r" : "";
+		const width = this.prefixWidth ?? visibleWidth(text);
+		return wrapLine(line.slice(0, line.length - cr.length), columns - width, width).map((piece) => text + piece).join("\n") + cr;
 	}
 };
+function isStreamDestination(destination) {
+	return destination === "stdout" || destination === "stderr";
+}
 //#endregion
 //#region src/run/Process.ts
 const USE_PROCESS_GROUPS = process.platform !== "win32";
@@ -1842,9 +1852,9 @@ var Process = class {
 	constructor(command, context) {
 		this.command = command;
 		this.context = context;
-		const { destinations, envColumns, formatLabel, wrap } = context.config;
-		const color = context.config.color !== "none";
-		const sink = (stream) => new OutputSink(command[stream], makePrefix(command, color, formatLabel, stream), destinations, context.files, wrap, envColumns);
+		const { color, formatLabel } = context.config;
+		const colored = color !== "none";
+		const sink = (stream) => new OutputSink(command[stream], makePrefix(command, colored, formatLabel, stream), context);
 		this.stdout = sink("stdout");
 		this.stderr = sink("stderr");
 	}
@@ -1862,12 +1872,13 @@ var Process = class {
 		let stopTheRun = false;
 		for (;;) {
 			this.started = true;
-			if (this.context.config.showCommand) {
-				const run = this.context.config.color === "none" ? "run" : paint("run", ["blue"]);
+			const { color, showCommand, showExitCode } = this.context.config;
+			if (showCommand) {
+				const run = paint("run", ["blue"], color !== "none");
 				this.stdout.writeLine(`${run} ${this.command.command}`);
 			}
 			await this.spawn();
-			if (this.context.config.showExitCode) this.stdout.writeLine(this.exitLine());
+			if (showExitCode) this.stdout.writeLine(this.exitLine());
 			this.stdout.flush();
 			this.stderr.flush();
 			this.context.logger.debug(`< ${this.command.line} ${this.describeExit()}`);
@@ -1895,12 +1906,12 @@ var Process = class {
 	* in gray, so it can be found without its label.
 	*/
 	exitLine() {
-		const color = this.context.config.color !== "none";
+		const colored = this.context.config.color !== "none";
 		const duration = formatDuration(performance.now() - this.attemptStart);
-		if (this.exitCode === 0 && this.signal === void 0 && !this.terminated) return `${color ? paint("✓", ["green"]) : "✓"} ${duration}`;
+		if (this.exitCode === 0 && this.signal === void 0 && !this.terminated) return `${paint("✓", ["green"], colored)} ${duration}`;
 		const [status, tint] = this.terminated ? ["– stopped", "yellow"] : [`✗ ${this.shortExit()}`, "red"];
-		const { command } = this.command;
-		return color ? `${paint(status, [tint])} · ${duration}  ${paint(command, ["gray"])}` : `${status} · ${duration}  ${command}`;
+		const command = paint(this.command.command, ["gray"], colored);
+		return `${paint(status, [tint], colored)} · ${duration}  ${command}`;
 	}
 	/** `code N`, the signal's name, or `stopped`. */
 	shortExit() {
@@ -2017,6 +2028,7 @@ async function schedule(processes, stopped, jobs) {
 //#region src/run/Run.ts
 /** One run: the processes built from a plan, and what stops them. */
 var Run = class Run {
+	/** @internal */
 	config;
 	/** @internal */
 	processes;
@@ -2025,9 +2037,8 @@ var Run = class Run {
 	stopping;
 	constructor({ commands, config, packageInfo }) {
 		this.config = config;
-		this.files = new FileRegistry(config.cwd);
+		this.files = new FileRegistry(config.cwd, () => this.stopEverything({ reason: "policy" }));
 		this.logger = new Logger(config.logLevel, config.destinations.stderr, config.color !== "none");
-		for (const warning of config.warnings) this.logger.warn(`runset: ${warning}`);
 		const context = {
 			config,
 			files: this.files,
@@ -2036,7 +2047,6 @@ var Run = class Run {
 			requestStop: () => this.stopEverything({ reason: "policy" })
 		};
 		this.processes = commands.map((command) => new Process(command, context));
-		this.files.onFailure(() => this.stopEverything({ reason: "policy" }));
 	}
 	/** A library caller's config object, through the same pipeline as the CLI. */
 	static fromConfigJs(configJs) {
@@ -2058,6 +2068,7 @@ var Run = class Run {
 	}
 	/** Rejects with a {@link RunsetError} when the run did not succeed. */
 	async start() {
+		for (const warning of this.config.warnings) this.logger.warn(`runset: ${warning}`);
 		if (this.config.dryRun) {
 			this.config.destinations.stdout.write(`${this.describe()}\n`);
 			return this;
@@ -2075,43 +2086,45 @@ var Run = class Run {
 			await this.files.closeAll();
 		}
 		const failed = this.failed();
-		const exitCode = failed[0]?.getReportedExitCode();
+		const exitCode = this.getExitCode();
 		const { stopping } = this;
-		if (this.files.error) throw new RunsetError(this.files.error.message, exitCode ?? 1);
+		if (this.files.error) throw new RunsetError(this.files.error.message, exitCode || 1);
 		if (stopping?.signal) throw new RunsetError(`the run was stopped by ${stopping.signal}`, signalExitCode(stopping.signal), "");
 		if (stopping?.reason === "terminate") throw new RunsetError("the run was terminated", signalExitCode("SIGTERM"));
-		if (exitCode !== void 0) throw new RunsetError(`${this.tally()}: ${failed.map((process) => describeFailure(process)).join(", ")}`, exitCode, this.failureReport());
+		if (failed.length > 0) {
+			const tally = this.tally(failed);
+			throw new RunsetError(`${tally}: ${failed.map((process) => describeFailure(process)).join(", ")}`, exitCode, this.failureReport(tally, failed));
+		}
 		return this;
 	}
 	terminate(options = {}) {
 		this.stopEverything({ reason: "terminate" }, options);
 	}
 	/** `1 of 5 commands failed, 2 stopped, 1 not started`. */
-	tally() {
+	tally(failed) {
 		const { processes } = this;
 		const total = processes.length;
 		const stopped = processes.filter((process) => process.started && process.terminated).length;
 		const notStarted = processes.filter((process) => !process.started).length;
 		return [
-			`${this.failed().length} of ${total} command${total === 1 ? "" : "s"} failed`,
+			`${failed.length} of ${total} command${total === 1 ? "" : "s"} failed`,
 			stopped > 0 && `${stopped} stopped`,
 			notStarted > 0 && `${notStarted} not started`
 		].filter(Boolean).join(", ");
 	}
 	/** The tally, then a row per failure, labelled as its output was. */
-	failureReport() {
-		const color = this.config.color !== "none";
-		const red = (text) => color ? paint(text, ["red"]) : text;
-		const rows = this.failed().map((process) => {
+	failureReport(tally, failed) {
+		const colored = this.config.color !== "none";
+		const red = (text) => paint(text, ["red"], colored);
+		return [tally, ...failed.map((process) => {
 			const { command } = process;
 			const label = command.label.trim();
-			const prefix = makePrefix({
+			const prefix = label === "" ? "" : defaultLabel({
 				...command,
 				label
-			}, color, void 0, "stderr");
+			}, colored);
 			return `  ${red("✖")} ${prefix}${command.command} ${red(process.describeExit())}`;
-		});
-		return [this.tally(), ...rows].join("\n");
+		})].join("\n");
 	}
 	failed() {
 		return this.processes.filter((process) => process.isFailed());
@@ -2190,7 +2203,7 @@ Output:
                              none | auto | custom | all (default: auto)
       --show-command         print each command as it starts
       --show-exit-code       mark each exit and its duration: ✓ 2.1s, ✗ code 1 · 2.1s
-  -w, --wrap                 wrap labelled lines to the terminal, a label on each
+      --no-wrap              leave long labelled lines whole instead of wrapping
 
 General:
   -c, --config <path>        load a config file, skipping the default lookup
@@ -2250,7 +2263,17 @@ function version() {
 async function runset(first, second) {
 	return Run.fromConfigJs(toConfigJs(first, second)).start();
 }
-if (import.meta.main) process.exitCode = await main(process.argv.slice(2));
+if (import.meta.main || isEntryPoint()) main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+}).catch((error) => {
+	console.error(error);
+	process.exitCode = 1;
+}).finally(() => {
+	setTimeout(() => {
+		console.error("runset: forced exit, a handle kept the process alive");
+		process.exit();
+	}, 500).unref();
+});
 /** A lone object carrying `commands` is a config; anything else is commands. */
 function toConfigJs(first, second) {
 	if (second === void 0 && isConfigObject(first)) return first;
@@ -2261,7 +2284,20 @@ function toConfigJs(first, second) {
 	};
 }
 function isConfigObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Array.isArray(value.commands);
+	return isPlainObject(value) && Array.isArray(value.commands);
+}
+/**
+* Node 24.2 reports `import.meta.main` as false for a `.ts` entry point, which
+* is how the tests run this file; 24.3 fixed it. The module URL is a real
+* path, so the argument is resolved to one too — macOS's temp dir is a link.
+*/
+function isEntryPoint() {
+	const entry = process.argv[1];
+	try {
+		return entry !== void 0 && fs.realpathSync(entry) === fileURLToPath(import.meta.url);
+	} catch {
+		return false;
+	}
 }
 //#endregion
-export { CliError, ConfigError, EXIT_ACTIONS, NormalizeError, Run, RunsetError, runset as default, runset, isCommandSettings, isStreamDestination };
+export { CliError, ConfigError, NormalizeError, Run, RunsetError, runset as default, runset };