stim 1.20.2 → 1.21.0

package/dist/exec-_UbtCQcG.mjs

@@ -0,0 +1,750 @@
+import { createRequire } from "node:module";
+import { ambientContext, ambientEnv } from "@stim-cli/core";
+import { createDebugLog, runId } from "@stim-cli/core/state";
+import { basename, delimiter, resolve } from "path";
+import { execSync } from "child_process";
+import spawn from "cross-spawn";
+import which from "which";
+import { fileURLToPath } from "node:url";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/debug-log.ts
+const debugLog = createDebugLog("cli", { base: () => ({ runId: runId() }) });
+//#endregion
+//#region src/report-runtime.ts
+const reports = /* @__PURE__ */ new WeakMap();
+function reportSignal(context) {
+	return context && reports.has(context) ? context.signal : void 0;
+}
+function trackReportResource(context, closed, cancel, signal = context?.signal) {
+	const state = context && reports.get(context);
+	if (!context || !state || !signal) return;
+	const { pending } = state;
+	const abort = () => {
+		const cancelled = Promise.resolve().then(cancel);
+		pending.add(cancelled);
+		cancelled.then(() => pending.delete(cancelled), (error) => {
+			state.failure ??= error;
+			pending.delete(cancelled);
+			pending.delete(closed);
+			signal.removeEventListener("abort", abort);
+		});
+	};
+	pending.add(closed);
+	const settled = () => {
+		signal.removeEventListener("abort", abort);
+		pending.delete(closed);
+	};
+	closed.then(settled, (error) => {
+		state.failure ??= error;
+		settled();
+	});
+	signal.addEventListener("abort", abort, { once: true });
+	if (signal.aborted) abort();
+}
+async function runReport(context, work) {
+	const controller = new AbortController();
+	const signal = AbortSignal.any([context.signal, controller.signal]);
+	const operation = {
+		...context,
+		signal,
+		output: ((stream, text) => {
+			if (!signal.aborted) context.output(stream, text);
+		})
+	};
+	const pending = /* @__PURE__ */ new Set();
+	const state = { pending };
+	reports.set(operation, state);
+	const deadline = performance.now() + 6e4;
+	const expire = () => {
+		controller.abort(Object.assign(/* @__PURE__ */ new Error("The report exceeded its 60 second budget."), { code: "STIM_REPORT_TIMEOUT" }));
+	};
+	const timer = setTimeout(expire, 6e4);
+	let rejectCancellation;
+	const cancelled = new Promise((_, reject) => {
+		rejectCancellation = reject;
+	});
+	const abort = () => rejectCancellation(signal.reason);
+	signal.addEventListener("abort", abort, { once: true });
+	const outcome = await (async () => {
+		try {
+			signal.throwIfAborted();
+			const result = await Promise.race([work(operation), cancelled]);
+			if (performance.now() >= deadline) expire();
+			signal.throwIfAborted();
+			return { result };
+		} catch (error) {
+			return { error };
+		}
+	})().finally(async () => {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", abort);
+		controller.abort();
+		const cleanupDeadline = performance.now() + 35e3;
+		const expireCleanup = () => {
+			state.failure ??= Object.assign(/* @__PURE__ */ new Error("Report cleanup did not finish within 35 seconds."), {
+				code: "STIM_CLAIM_UNAVAILABLE",
+				reportCleanup: true
+			});
+		};
+		let cleanupTimer;
+		try {
+			await Promise.race([(async () => {
+				while (pending.size) await Promise.allSettled(pending);
+			})(), new Promise((resolve) => {
+				cleanupTimer = setTimeout(() => {
+					expireCleanup();
+					resolve();
+				}, 35e3);
+			})]);
+			if (performance.now() >= cleanupDeadline) expireCleanup();
+		} finally {
+			clearTimeout(cleanupTimer);
+		}
+	});
+	if ("failure" in state) throw state.failure;
+	if ("error" in outcome) throw outcome.error;
+	return outcome.result;
+}
+//#endregion
+//#region src/process-identity.ts
+var process_identity_exports = /* @__PURE__ */ __exportAll({});
+import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
+__reExport(process_identity_exports, import__stim_cli_core_process_identity);
+//#endregion
+//#region src/ownership-claim.ts
+var ownership_claim_exports = /* @__PURE__ */ __exportAll({});
+import * as import__stim_cli_core_ownership_claim from "@stim-cli/core/ownership-claim";
+__reExport(ownership_claim_exports, import__stim_cli_core_ownership_claim);
+//#endregion
+//#region src/engine/operation-state.ts
+const states = /* @__PURE__ */ new WeakMap();
+let detached;
+function fresh() {
+	return {
+		cancelled: null,
+		runSignal: void 0,
+		declaring: /* @__PURE__ */ new Set(),
+		running: /* @__PURE__ */ new Set(),
+		refusal: null,
+		handled: false,
+		draining: false,
+		exitCleanups: /* @__PURE__ */ new Set(),
+		buildMachineFlag: void 0,
+		takesSignals: false,
+		abortOperation: void 0
+	};
+}
+/** The state of `context`'s operation; code that is not passed a context yet shares one state per process. */
+function operationState(context) {
+	if (!context) return detached ??= fresh();
+	let state = states.get(context);
+	if (!state) {
+		state = fresh();
+		states.set(context, state);
+	}
+	return state;
+}
+/** Whether an abort reason asks the operation to terminate rather than interrupt it. */
+function isTermination(reason) {
+	return reason === "SIGTERM";
+}
+/** Keeps asynchronous work unwinding on the CLI's first interrupt until its owned work has settled. */
+async function withDrainingCancellation(context, signal, work) {
+	if (!context) return work();
+	const abort = () => {
+		const state = operationState(context);
+		state.handled = true;
+		if (!isTermination(context.signal.reason)) state.draining = true;
+	};
+	signal?.addEventListener("abort", abort, { once: true });
+	if (signal?.aborted) abort();
+	try {
+		return await work();
+	} finally {
+		signal?.removeEventListener("abort", abort);
+	}
+}
+//#endregion
+//#region src/engine/spawn-claims.ts
+/**
+* Record every child `context`'s operation later starts through `spawnDeclared` on `claim` until
+* `stopDeclaringSpawnsOn(context, claim)`.
+*/
+function declareSpawnsOn(context, claim) {
+	if (claim) operationState(context).declaring.add(claim);
+}
+function stopDeclaringSpawnsOn(context, claim) {
+	if (claim) operationState(context).declaring.delete(claim);
+}
+/**
+* Start a child that every claim `context`'s operation passed to `declareSpawnsOn` records until it exits. The child keeps
+* the caller's process group, so a terminal interrupt still reaches it; the claim follows the child
+* itself. A claim that cannot be marked stops the spawn rather than letting it run unprotected. A claim
+* records one child, so declared spawns must not overlap. `until: 'close'` also holds the declaration
+* while a launcher's child retains its stdio pipes after the launcher exits.
+*/
+function spawnDeclared(context, spawn, { until = "exit" } = {}) {
+	const { declaring, running, refusal } = operationState(context);
+	if (refusal !== null) throw new Error(refusal);
+	const claims = [...declaring];
+	if (claims.length === 0) return spawn();
+	const forget = () => {
+		for (const claim of claims) try {
+			(0, ownership_claim_exports.clearClaimChild)(claim);
+		} catch {}
+	};
+	let child;
+	try {
+		for (const claim of claims) (0, ownership_claim_exports.markClaimChildPending)(claim);
+		child = spawn();
+	} catch (error) {
+		forget();
+		throw error;
+	}
+	const pid = child.pid;
+	if (pid === void 0) {
+		forget();
+		return child;
+	}
+	running.add(child);
+	child.once(until, () => running.delete(child));
+	const captured = (0, process_identity_exports.captureProcessIdentity)(pid);
+	if (captured.ok) for (const claim of claims) try {
+		(0, ownership_claim_exports.setClaimChild)(claim, {
+			pid,
+			processToken: captured.token
+		});
+	} catch {}
+	child.once(until, forget);
+	return child;
+}
+/** Refuse every later `spawnDeclared` of `context`'s operation with `reason` until `allowDeclaredSpawns`. */
+function refuseDeclaredSpawns(context, reason) {
+	operationState(context).refusal = reason;
+}
+function allowDeclaredSpawns(context) {
+	operationState(context).refusal = null;
+}
+/**
+* Send `signal` to every child `context`'s operation started through `spawnDeclared` that has not exited; returns how
+* many were signalled.
+*/
+function signalDeclaredSpawns(context, signal) {
+	let signalled = 0;
+	for (const child of operationState(context).running) {
+		if (child.exitCode !== null || child.signalCode !== null) continue;
+		try {
+			if (child.kill(signal)) signalled += 1;
+		} catch {}
+	}
+	return signalled;
+}
+//#endregion
+//#region src/exec.ts
+const MAX_BUFFER = 67108864;
+function spawnReportProbe(file, args, opts) {
+	if (process.platform !== "win32" || !reportSignal(ambientContext()) || !executableIn(file, opts.env ?? ambientEnv(), opts.cwd ?? process.cwd())) return spawn(file, args, opts);
+	const env = opts.env ?? ambientEnv();
+	const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
+	if (!systemRoot) throw new Error("SystemRoot is required to contain Windows report probes.");
+	return spawn(resolve(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), [
+		"-NoLogo",
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-File",
+		fileURLToPath(new URL("../dist/windows-report.ps1", import.meta.url))
+	], {
+		...opts,
+		windowsHide: true,
+		env: {
+			...env,
+			STIM_REPORT_CHILD: JSON.stringify({
+				file,
+				args,
+				node: process.execPath,
+				entry: fileURLToPath(new URL("../dist/windows-report.mjs", import.meta.url))
+			})
+		}
+	});
+}
+function reportChild(child, signal, failed) {
+	const context = ambientContext();
+	const report = reportSignal(context);
+	signal ??= report;
+	if (!signal) return;
+	let rejectClosed;
+	let ended = false;
+	let finishNativeClose;
+	const nativeClosed = new Promise((resolve) => {
+		finishNativeClose = resolve;
+	});
+	const closed = new Promise((resolve, reject) => {
+		rejectClosed = reject;
+		child.once("close", () => {
+			ended = true;
+			finishNativeClose();
+			if (report) cancel().then(resolve, reject);
+			else resolve();
+		});
+	});
+	const pid = child.pid;
+	const captured = pid === void 0 ? null : (0, process_identity_exports.captureProcessIdentity)(pid);
+	const observe = () => {
+		if (pid === void 0) return "gone";
+		if (captured?.ok) return (0, process_identity_exports.inspectProcessIdentity)({
+			pid,
+			processToken: captured.token
+		});
+		if (process.platform === "win32") return ended ? "gone" : "unknown";
+		try {
+			process.kill(-pid, 0);
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ESRCH") return "gone";
+		}
+		return "unknown";
+	};
+	const refuse = (message) => {
+		const error = Object.assign(new Error(message), {
+			code: "STIM_CLAIM_UNAVAILABLE",
+			reportCleanup: true
+		});
+		child.stdin?.destroy();
+		child.stdout?.destroy();
+		child.stderr?.destroy();
+		child.unref();
+		failed?.(error);
+		rejectClosed(error);
+		throw error;
+	};
+	let cancelled;
+	const cancel = () => cancelled ??= (async () => {
+		let identity = observe();
+		if (pid !== void 0) {
+			const deadline = performance.now() + 1e3;
+			while (identity === "unknown" && performance.now() < deadline) {
+				await setTimeout$1(50);
+				identity = observe();
+			}
+			if (identity === "unknown") refuse(`Cannot verify cleanup for report child ${pid}; its process or descendants were left untouched.`);
+		}
+		if (pid !== void 0 && captured?.ok && (identity === "same" || process.platform !== "win32" && identity === "gone")) {
+			if (process.platform === "win32") {
+				if (report) child.kill("SIGKILL");
+				else {
+					const killer = spawn("taskkill", [
+						"/PID",
+						String(pid),
+						"/T",
+						"/F"
+					], { stdio: "ignore" });
+					const timer = setTimeout(() => killer.kill("SIGKILL"), 5e3);
+					await new Promise((resolve) => {
+						killer.once("error", () => child.kill("SIGKILL"));
+						killer.once("close", (status) => {
+							if (status !== 0) child.kill("SIGKILL");
+							resolve();
+						});
+					});
+					clearTimeout(timer);
+				}
+			} else try {
+				process.kill(-pid, "SIGKILL");
+			} catch {
+				child.kill("SIGKILL");
+			}
+		}
+		child.stdin?.destroy();
+		child.stdout?.destroy();
+		child.stderr?.destroy();
+		if (!ended) {
+			let timer;
+			await Promise.race([nativeClosed, new Promise((resolve) => {
+				timer = setTimeout(resolve, 1e3);
+			})]);
+			clearTimeout(timer);
+			if (!ended) refuse(`Report child ${pid} did not close within the cleanup budget.`);
+		}
+	})();
+	if (report) trackReportResource(context, closed, cancel, signal);
+	else {
+		const abort = () => {
+			cancel().catch(() => {});
+		};
+		const callerSignal = signal;
+		callerSignal.addEventListener("abort", abort, { once: true });
+		const settled = () => callerSignal.removeEventListener("abort", abort);
+		closed.then(settled, settled);
+		if (callerSignal.aborted) abort();
+	}
+	return cancel;
+}
+function budgetMs(timeoutMs) {
+	if (timeoutMs === "unbounded") return void 0;
+	if (!(timeoutMs > 0)) throw new RangeError(`timeoutMs must be a positive number of milliseconds or 'unbounded', got ${timeoutMs}`);
+	return timeoutMs;
+}
+/** Whether an exec error is a child killed for exceeding its `timeoutMs`. */
+function isTimeoutError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ETIMEDOUT";
+}
+function nameTimeout(error, command, timeoutMs) {
+	if (error?.code === "ETIMEDOUT" && error instanceof Error) error.message = `Command timed out after ${timeoutMs}ms: ${command}`;
+	return error;
+}
+const WINDOWS_BATCH_FILE = /\.(?:bat|cmd)$/i;
+const BATCH_UNSAFE_ARGUMENT = /["\r\n]/;
+function isUnsafeBatchSpawn(target, args, platform = process.platform) {
+	return platform === "win32" && WINDOWS_BATCH_FILE.test(target) && args.some((arg) => BATCH_UNSAFE_ARGUMENT.test(arg));
+}
+function executableIn(file, env, cwd) {
+	const windows = process.platform === "win32";
+	const value = (name) => env[name] ?? (windows ? Object.entries(env).find(([key, field]) => field !== void 0 && key.toUpperCase() === name)?.[1] : void 0);
+	const directory = typeof cwd === "string" ? cwd : fileURLToPath(cwd);
+	const path = file.includes("/") || windows && file.includes("\\");
+	const directories = path ? [""] : (value("PATH") ?? "").split(delimiter);
+	if (windows && !path) directories.unshift(directory);
+	for (const entry of directories) {
+		const candidate = resolve(directory, entry.replace(/^"(.*)"$/, "$1"), file);
+		const found = which.sync(candidate, {
+			nothrow: true,
+			path: "",
+			pathExt: value("PATHEXT") ?? ""
+		});
+		if (found) return found;
+	}
+	return null;
+}
+function refuseUnsafeBatchArguments(file, args, env = ambientEnv(), cwd = ambientContext()?.cwd ?? process.cwd()) {
+	if (process.platform !== "win32") return;
+	const target = executableIn(file, env, cwd) ?? file;
+	if (isUnsafeBatchSpawn(target, args)) throw new Error(`Refusing to run ${basename(target)}: an argument contains a character cmd.exe could misinterpret (a double quote or a line break).`);
+}
+function redactError(error, values) {
+	const secrets = values?.filter(Boolean) ?? [];
+	if (secrets.length === 0 || !error || typeof error !== "object") return error;
+	const scrub = (text) => secrets.reduce((acc, secret) => acc.split(secret).join("***"), text);
+	const fields = error;
+	for (const key of Object.getOwnPropertyNames(error)) {
+		const value = fields[key];
+		if (typeof value === "string") fields[key] = scrub(value);
+		else if (Array.isArray(value)) fields[key] = value.map((item) => typeof item === "string" ? scrub(item) : item);
+	}
+	return error;
+}
+const defaultExecutor = {
+	reportSignal: () => reportSignal(ambientContext()),
+	run(cmd, { timeoutMs, killSignal, cwd, env }) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		const timeout = budgetMs(timeoutMs);
+		if (timeout !== void 0) opts.timeout = timeout;
+		if (killSignal) opts.killSignal = killSignal;
+		const childCwd = cwd ?? ambientContext()?.cwd;
+		if (childCwd) opts.cwd = childCwd;
+		if (env || ambientContext()) opts.env = {
+			...ambientEnv(),
+			...env
+		};
+		try {
+			return String(execSync(cmd, opts)).trim();
+		} catch (error) {
+			throw nameTimeout(error, cmd, timeoutMs);
+		}
+	},
+	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed, rejectStderr, detachedSilent, redact }) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: detachedSilent ? "ignore" : [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		if (detachedSilent) opts.detached = true;
+		const timeout = budgetMs(timeoutMs);
+		if (timeout !== void 0) opts.timeout = timeout;
+		if (killSignal) opts.killSignal = killSignal;
+		const childCwd = cwd ?? ambientContext()?.cwd;
+		if (childCwd) opts.cwd = childCwd;
+		if (input !== void 0) opts.input = input;
+		if (env || omitEnv?.length || ambientContext()) {
+			const childEnv = {
+				...ambientEnv(),
+				...env
+			};
+			for (const key of omitEnv ?? []) delete childEnv[key];
+			opts.env = childEnv;
+		}
+		refuseUnsafeBatchArguments(file, args, opts.env, opts.cwd);
+		const result = spawn.sync(file, args, opts);
+		if (result.error) throw redactError(nameTimeout(Object.assign(result.error, result), [file, ...args].join(" "), timeoutMs), redact);
+		if (result.status !== 0 || rejectStderr && String(result.stderr ?? "").trim()) {
+			const stderr = String(result.stderr ?? "");
+			const message = `Command failed: ${[file, ...args].join(" ")}${stderr ? `\n${stderr}` : ""}`;
+			throw redactError(Object.assign(new Error(message), result), redact);
+		}
+		if (detachedSilent) return "";
+		return untrimmed ? String(result.stdout) : String(result.stdout).trim();
+	},
+	runFileAsync(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed, rejectStderr, onSpawn, declareFor, detachedSilent, redact, signal: callSignal }) {
+		const command = [file, ...args].join(" ");
+		return new Promise((resolve, reject) => {
+			const report = callSignal ?? reportSignal(ambientContext());
+			report?.throwIfAborted();
+			const timeout = budgetMs(timeoutMs);
+			const opts = detachedSilent ? {
+				stdio: "ignore",
+				detached: true
+			} : { stdio: [
+				input === void 0 ? "ignore" : "pipe",
+				"pipe",
+				"pipe"
+			] };
+			if (report && process.platform !== "win32") opts.detached = true;
+			const childCwd = cwd ?? ambientContext()?.cwd;
+			if (childCwd) opts.cwd = childCwd;
+			if (env || omitEnv?.length || ambientContext()) {
+				const childEnv = {
+					...ambientEnv(),
+					...env
+				};
+				for (const key of omitEnv ?? []) delete childEnv[key];
+				opts.env = childEnv;
+			}
+			refuseUnsafeBatchArguments(file, args, opts.env, opts.cwd);
+			const start = () => spawnReportProbe(file, args, opts);
+			const child = declareFor ? spawnDeclared(declareFor, start) : start();
+			let cancel;
+			let timer;
+			try {
+				cancel = reportChild(child, report, (error) => {
+					clearTimeout(timer);
+					reject(error);
+				});
+				onSpawn?.(child);
+			} catch (error) {
+				if (cancel) cancel().catch(reject);
+				else if (!report) child.kill("SIGKILL");
+				reject(error);
+				return;
+			}
+			if (input !== void 0) {
+				child.stdin?.on("error", () => {});
+				child.stdin?.end(input);
+			}
+			const stdout = [];
+			const stderr = [];
+			let timedOut = false;
+			let overflowed = false;
+			let bufferedBytes = 0;
+			const capture = (chunks, chunk) => {
+				if (overflowed) return;
+				const remaining = MAX_BUFFER - bufferedBytes;
+				if (chunk.length <= remaining) {
+					chunks.push(chunk);
+					bufferedBytes += chunk.length;
+				} else {
+					if (remaining > 0) chunks.push(chunk.subarray(0, remaining));
+					bufferedBytes = MAX_BUFFER;
+					overflowed = true;
+					if (cancel) cancel().catch(reject);
+					else {
+						child.kill("SIGKILL");
+						child.stdin?.destroy();
+						child.stdout?.destroy();
+						child.stderr?.destroy();
+					}
+				}
+			};
+			timer = timeout === void 0 ? void 0 : setTimeout(() => {
+				timedOut = true;
+				if (cancel) cancel().catch(reject);
+				else {
+					child.kill(killSignal ?? "SIGTERM");
+					child.stdin?.destroy();
+					child.stdout?.destroy();
+					child.stderr?.destroy();
+				}
+			}, timeout);
+			child.stdout?.on("data", (chunk) => capture(stdout, chunk));
+			child.stderr?.on("data", (chunk) => capture(stderr, chunk));
+			child.on("error", (error) => {
+				clearTimeout(timer);
+				reject(redactError(error, redact));
+			});
+			child.on("close", (status, signal) => {
+				clearTimeout(timer);
+				const discardOutput = (timedOut || overflowed || report?.aborted) && redact?.some(Boolean);
+				const out = discardOutput ? "" : Buffer.concat(stdout).toString("utf-8");
+				const err = discardOutput ? "" : Buffer.concat(stderr).toString("utf-8");
+				const result = {
+					status,
+					signal,
+					stdout: out,
+					stderr: err
+				};
+				if (report?.aborted) reject(report.reason);
+				else if (timedOut) reject(redactError(nameTimeout(Object.assign(new Error(command), result, { code: "ETIMEDOUT" }), command, timeoutMs), redact));
+				else if (overflowed) reject(redactError(Object.assign(/* @__PURE__ */ new Error(`Command output exceeded ${MAX_BUFFER} bytes: ${command}`), result, { code: "ENOBUFS" }), redact));
+				else if (status !== 0 || rejectStderr && err.trim()) reject(redactError(Object.assign(/* @__PURE__ */ new Error(`Command failed: ${command}${err ? `\n${err}` : ""}`), result), redact));
+				else resolve(detachedSilent ? "" : untrimmed ? out : out.trim());
+			});
+		});
+	},
+	runQuiet(cmd, opts) {
+		budgetMs(opts.timeoutMs);
+		try {
+			return this.run(cmd, opts);
+		} catch {
+			return null;
+		}
+	},
+	runFileQuiet(file, args, opts) {
+		budgetMs(opts.timeoutMs);
+		try {
+			return this.runFile(file, args, opts);
+		} catch {
+			return null;
+		}
+	},
+	runFileQuietAsync(file, args, opts) {
+		budgetMs(opts.timeoutMs);
+		return this.runFileAsync(file, args, opts).catch(() => null);
+	},
+	spawn(cmd, args = [], opts = {}) {
+		const report = reportSignal(ambientContext());
+		report?.throwIfAborted();
+		const context = ambientContext();
+		const childOpts = context ? {
+			...opts,
+			cwd: opts.cwd ?? context.cwd,
+			env: opts.env ?? context.env
+		} : opts;
+		if (report && process.platform !== "win32") childOpts.detached = true;
+		refuseUnsafeBatchArguments(cmd, args, childOpts.env ?? ambientEnv(), childOpts.cwd);
+		const child = spawnReportProbe(cmd, args, childOpts);
+		reportChild(child);
+		return child;
+	},
+	findExecutable(name) {
+		return executableIn(name, ambientEnv(), ambientContext()?.cwd ?? process.cwd());
+	}
+};
+/** The program a call runs, without its arguments: those can carry tokens. */
+const programOf = (command) => basename(command.trim().split(/\s+/)[0] ?? "");
+function outcomeOf(error) {
+	const { status, signal, code } = error ?? {};
+	return {
+		ok: false,
+		...typeof status === "number" ? { exit: status } : {},
+		...signal ? { signal } : {},
+		...code ? { code } : {}
+	};
+}
+let executionId = 0;
+function timedSync(fn, program) {
+	return (...args) => {
+		if (!debugLog.enabled()) return fn(...args);
+		const id = ++executionId;
+		const name = program(...args);
+		const started = performance.now();
+		debugLog.log("exec.start", {
+			program: name,
+			executionId: id
+		});
+		try {
+			const out = fn(...args);
+			debugLog.log("exec", {
+				program: name,
+				executionId: id,
+				ms: Math.round(performance.now() - started),
+				ok: true
+			});
+			return out;
+		} catch (error) {
+			debugLog.log("exec", {
+				program: name,
+				executionId: id,
+				ms: Math.round(performance.now() - started),
+				...outcomeOf(error)
+			});
+			throw error;
+		}
+	};
+}
+let active = {
+	...defaultExecutor,
+	run: timedSync((cmd, opts) => defaultExecutor.run(cmd, opts), programOf),
+	runFile: timedSync((file, args, opts) => defaultExecutor.runFile(file, args, opts), (file) => basename(file)),
+	async runFileAsync(file, args, opts) {
+		if (!debugLog.enabled()) return defaultExecutor.runFileAsync(file, args, opts);
+		const id = ++executionId;
+		const name = basename(file);
+		const started = performance.now();
+		debugLog.log("exec.start", {
+			program: name,
+			executionId: id
+		});
+		try {
+			const out = await defaultExecutor.runFileAsync(file, args, opts);
+			debugLog.log("exec", {
+				program: name,
+				executionId: id,
+				ms: Math.round(performance.now() - started),
+				ok: true
+			});
+			return out;
+		} catch (error) {
+			debugLog.log("exec", {
+				program: name,
+				executionId: id,
+				ms: Math.round(performance.now() - started),
+				...outcomeOf(error)
+			});
+			throw error;
+		}
+	}
+};
+function getExecutor() {
+	return active;
+}
+//#endregion
+export { debugLog as _, refuseDeclaredSpawns as a, stopDeclaringSpawnsOn as c, withDrainingCancellation as d, ownership_claim_exports as f, trackReportResource as g, runReport as h, declareSpawnsOn as i, isTermination as l, reportSignal as m, isTimeoutError as n, signalDeclaredSpawns as o, process_identity_exports as p, allowDeclaredSpawns as r, spawnDeclared as s, getExecutor as t, operationState as u, __commonJSMin as v, __require as y };