stim 1.20.2 → 1.22.0

package/dist/budget-f7516Zk0.mjs

@@ -1,4106 +0,0 @@
-import { D as withConfigLock$1, I as measuredDirectorySize, L as volumeRootFor, M as directorySize, N as formatBytes, P as isOnMountedVolume, V as deviceSlotPlatforms, W as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, j as ownership_claim_exports, k as process_identity_exports, o as clearSupervisor, p as getProject } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { i as registeredCaches } from "./cache-manifest-XH-fvDUj.mjs";
-import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-BX1sJQ2E.mjs";
-import { a as updateWorkspaceState, c as writeWorkspaceState, m as sharedBuildCache, r as readWorkspaceState$1, t as clearWorkspaceStateKey, w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { a as formatElapsed, l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { A as clearWorkspaceSupervisor, M as readPidFile } from "./project-_phNIJfs.mjs";
-import { A as listAvds, I as ownedAvdDirectory, ft as readParked, it as isStimOwnedSim, rt as isStimOwnedAvd, st as dropParked, z as ownedAvdSerialResolver } from "./android-Mz_Inn3w.mjs";
-import { r as killMetroTree, u as resolveProjectMetro } from "./metro-DnCEjCxs.mjs";
-import { C as recordGcResult, I as listBuildSlots, P as resolveSupervisorTarget, S as teardownParkedIosSim, T as canonicalPath, a as collectWorkspaceOutputs, b as teardownOwnedIosSim, f as withIdleWorkspace, g as eraseParkedIosSim, h as eraseParkedAvd, r as clearWorkspaceOutputs, v as teardownOwnedAvd, x as teardownParkedAvd } from "./workspaces-C36s2jb9.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-4WopRPg-.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { n as supervisorError } from "./errors-DzkMYh8Q.mjs";
-import { a as parseWatchmanPid, d as capacity, g as formatSpace, h as environmentState, i as parseWatchmanClients, n as parseTriggerCount, r as parseWatchRoots, t as parseSubscriberNames } from "./watchman-CPQFZLXY.mjs";
-import { i as createDeviceProcessTables, o as idleForMs, p as workspaceActivity, r as createActivityReader } from "./activity-BSV745Kz.mjs";
-import { d as listAllIosSims, p as listIosDeviceTypes, y as parseRuntimeVersion } from "./ios-RkW4pnQf.mjs";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, statfsSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, DEV_SERVER_STOP_REQUEST_KEY, LAST_BUILD_KEYS, MACHINE_OWNER_KINDS, STATS_VERSION, buildWorkerRoot, decodeStats, isJsonObject, loadConfig, parseMissReason, readDevServerStop, readDevServerStopRequest, readRunEstimates, readStats as readStats$1, settingDefinition, settingValueError, statsFile, statsProjectKey as statsProjectKey$1, trimCapacityRefusals, trimCapacityWaits, trimSamples, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
-import { fileURLToPath } from "node:url";
-import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
-import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, cacheDirRefusal, compiledHelper, configDir } from "@stim-cli/core";
-import { homedir, tmpdir } from "os";
-import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
-import chalk from "chalk";
-//#region src/engine/stats.ts
-const PLACEMENT_MAX_AGE_MS = 6048e5;
-function emptyStats() {
-	return {
-		version: STATS_VERSION,
-		machine: {},
-		projects: {}
-	};
-}
-function updateStats(record, run, now) {
-	const at = new Date(now).toISOString();
-	const durationMs = wholeMs(run.durationMs);
-	const phases = {
-		coldBuildMs: wholeMs(run.coldBuildMs),
-		podsMs: wholeMs(run.podsMs)
-	};
-	const projects = { ...record.projects };
-	const scope = { ...projects[run.projectKey] };
-	const machine = { ...record.machine };
-	const before = scope[run.platform] ?? null;
-	const credit = creditMs(before, run, durationMs);
-	scope[run.platform] = applyRun(before, run, {
-		at,
-		durationMs,
-		credit,
-		phases
-	});
-	projects[run.projectKey] = scope;
-	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
-		at,
-		durationMs,
-		credit,
-		phases
-	});
-	const history = { ...record.history };
-	if (run.phases && !run.failed && !run.waitedForBuild && !run.offloadedTo) {
-		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
-		const project = { ...history[run.projectKey] };
-		const lists = { ...project[run.platform] };
-		const sample = {
-			at,
-			durationMs,
-			phases: wholePhases(run.phases),
-			...run.deviceSetup === void 0 ? {} : { deviceSetup: run.deviceSetup }
-		};
-		lists[outcome] = trimSamples([...lists[outcome] ?? [], sample]);
-		project[run.platform] = lists;
-		history[run.projectKey] = project;
-	}
-	let placements = record.placements;
-	let buildMachines = record.buildMachines;
-	if (run.placement) {
-		const placement = buildPlacement(run, before, at);
-		placements = trimPlacements([...placements ?? [], placement], now);
-		if (placement.machine && placement.decision !== "here") buildMachines = {
-			...buildMachines,
-			[placement.machine]: applyPlacement(buildMachines?.[placement.machine], placement)
-		};
-	}
-	const capacityRefusals = trimCapacityRefusals(record.capacityRefusals ?? [], now);
-	const capacityWaits = trimCapacityWaits(record.capacityWaits ?? [], now);
-	return {
-		version: STATS_VERSION,
-		machine,
-		projects,
-		...Object.keys(history).length ? { history } : {},
-		...placements?.length ? { placements } : {},
-		...capacityRefusals.length ? { capacityRefusals } : {},
-		...capacityWaits.length ? { capacityWaits } : {},
-		...buildMachines && Object.keys(buildMachines).length ? { buildMachines } : {}
-	};
-}
-function buildPlacement(run, before, at) {
-	const placement = run.placement;
-	const buildMs = wholeMs(placement.decision === "offloaded" ? placement.buildMs : run.coldBuildMs);
-	const localEstimateMs = wholeMs(before?.lastColdBuildMs);
-	const slotWaitMs = wholeMs(placement.slotWaitMs);
-	const deviceSlotWaitMs = wholeMs(placement.deviceSlotWaitMs);
-	return {
-		at,
-		project: run.projectKey,
-		platform: run.platform,
-		decision: placement.decision,
-		reason: placement.reason,
-		...placement.machine ? { machine: placement.machine } : {},
-		...buildMs > 0 ? { buildMs } : {},
-		...slotWaitMs > 0 ? { slotWaitMs } : {},
-		...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {},
-		...localEstimateMs > 0 ? { localEstimateMs } : {},
-		...run.failed ? { failed: true } : {}
-	};
-}
-function applyPlacement(totals, placement) {
-	const next = totals ? { ...totals } : {
-		offloaded: 0,
-		offloadedMs: 0,
-		savedMs: 0,
-		fallbacks: 0
-	};
-	if (placement.decision === "fell-back") {
-		next.fallbacks += 1;
-		next.lastFallbackAt = placement.at;
-		return next;
-	}
-	next.offloaded += 1;
-	next.offloadedMs += placement.buildMs ?? 0;
-	if (placement.localEstimateMs && placement.buildMs) next.savedMs += placement.localEstimateMs - placement.buildMs;
-	next.lastOffloadAt = placement.at;
-	return next;
-}
-function trimPlacements(placements, now) {
-	return placements.filter((each) => now - Date.parse(each.at) <= PLACEMENT_MAX_AGE_MS).slice(-100);
-}
-function recordRunStats(run, now) {
-	return withConfigLock$1(() => {
-		const path = statsFile();
-		const loaded = loadForUpdate(path, now);
-		if (loaded.newerVersion !== null) return {
-			recorded: false,
-			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
-		};
-		writeStats(path, updateStats(loaded.record, run, now));
-		return {
-			recorded: true,
-			note: loaded.note
-		};
-	});
-}
-function recordCapacityRefusal(event, now) {
-	try {
-		withConfigLock$1(() => {
-			const path = statsFile();
-			const loaded = loadForUpdate(path, now, false);
-			if (!loaded.record || loaded.newerVersion !== null) return;
-			const capacityRefusals = trimCapacityRefusals([...loaded.record.capacityRefusals ?? [], {
-				...event,
-				at: new Date(now).toISOString(),
-				kind: "device"
-			}], now);
-			writeStats(path, {
-				...loaded.record,
-				capacityRefusals
-			});
-		});
-	} catch {}
-}
-function recordCapacityWait(event, now) {
-	try {
-		withConfigLock$1(() => {
-			const path = statsFile();
-			const loaded = loadForUpdate(path, now, false);
-			if (!loaded.record || loaded.newerVersion !== null) return;
-			const capacityWaits = trimCapacityWaits([...loaded.record.capacityWaits ?? [], {
-				platform: event.platform,
-				max: event.max,
-				workspace: event.workspace,
-				ms: wholeMs(event.ms),
-				...event.reclaimed && Number.isInteger(event.reclaimed) && event.reclaimed > 0 ? { reclaimed: event.reclaimed } : {},
-				at: new Date(now).toISOString(),
-				kind: "device-wait"
-			}], now);
-			writeStats(path, {
-				...loaded.record,
-				capacityWaits
-			});
-		});
-	} catch {}
-}
-function createRunRecorder({ platform, write, now, note, phases, deviceSetup }) {
-	let projectKey = null;
-	let cacheKey = null;
-	let coldBuildMs = 0;
-	let podsMs = 0;
-	let placement = null;
-	let deviceSlotWaitMs = 0;
-	let recorded = false;
-	return {
-		setProject(key) {
-			projectKey = key;
-		},
-		setCacheKey(key) {
-			cacheKey = key;
-		},
-		setBuildMs(ms) {
-			coldBuildMs = wholeMs(ms);
-		},
-		setPodsMs(ms) {
-			podsMs = wholeMs(ms);
-		},
-		addDeviceSlotWaitMs(ms) {
-			deviceSlotWaitMs += wholeMs(ms);
-		},
-		deviceSlotWaitMs() {
-			return deviceSlotWaitMs || void 0;
-		},
-		setPlacement(next) {
-			placement = next;
-		},
-		record({ failed, cacheHit = false, waited = null, durationMs, offloadedTo = null }) {
-			if (!projectKey || !cacheKey || recorded) return;
-			recorded = true;
-			const ran = failed ? {} : phases?.() ?? {};
-			try {
-				const outcome = write({
-					platform,
-					projectKey,
-					failed,
-					cacheHit,
-					waitedForBuild: Boolean(waited),
-					durationMs,
-					...offloadedTo ? { offloadedTo } : {},
-					...coldBuildMs > 0 ? { coldBuildMs } : {},
-					...podsMs > 0 ? { podsMs } : {},
-					...Object.keys(ran).length ? { phases: ran } : {},
-					...failed || deviceSetup?.() === void 0 ? {} : { deviceSetup: deviceSetup() },
-					...placement ? { placement: {
-						...placement,
-						...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {}
-					} } : {}
-				}, now());
-				if (outcome?.note) note(outcome.note);
-			} catch (error) {
-				note(`Run statistics could not be recorded: ${error?.message || error}`);
-			}
-		}
-	};
-}
-function loadForUpdate(path, now, recoverCorrupt = true) {
-	let text;
-	try {
-		text = readFileSync(path, "utf-8");
-	} catch {
-		return {
-			record: emptyStats(),
-			note: null,
-			newerVersion: null
-		};
-	}
-	const parsed = decodeStats(text);
-	if (!parsed.record && parsed.newerVersion === null) {
-		if (!recoverCorrupt) return {
-			record: null,
-			note: null,
-			newerVersion: null
-		};
-		const aside = `${path}.corrupt-${now}`;
-		renameSync(path, aside);
-		return {
-			record: emptyStats(),
-			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
-			newerVersion: null
-		};
-	}
-	if (parsed.newerVersion !== null) return {
-		record: emptyStats(),
-		note: null,
-		newerVersion: parsed.newerVersion
-	};
-	return {
-		record: parsed.record,
-		note: null,
-		newerVersion: null
-	};
-}
-function writeStats(path, record) {
-	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
-	try {
-		renameSync(tmp, path);
-	} catch (error) {
-		rmSync(tmp, { force: true });
-		throw error;
-	}
-}
-function applyRun(bucket, run, { at, durationMs, credit, phases }) {
-	const next = bucket ? { ...bucket } : {
-		runs: 0,
-		failed: 0,
-		hits: 0,
-		misses: 0,
-		coldRuns: 0,
-		coldRunMs: 0,
-		hitRuns: 0,
-		hitRunMs: 0,
-		timeSavedMs: 0,
-		firstRunAt: at,
-		lastRunAt: at
-	};
-	next.runs += 1;
-	next.lastRunAt = at;
-	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
-	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
-	if (run.failed) {
-		next.failed += 1;
-		return next;
-	}
-	if (isHit(run.cacheHit)) {
-		next.hits += 1;
-		if (!run.waitedForBuild) {
-			next.hitRuns += 1;
-			next.hitRunMs += durationMs;
-			next.timeSavedMs += credit;
-		}
-		return next;
-	}
-	next.misses += 1;
-	if (run.offloadedTo) {
-		next.offloadedRuns = (next.offloadedRuns ?? 0) + 1;
-		next.offloadedRunMs = (next.offloadedRunMs ?? 0) + durationMs;
-		next.lastOffloadHost = run.offloadedTo;
-		return next;
-	}
-	next.coldRuns += 1;
-	next.coldRunMs += durationMs;
-	return next;
-}
-function creditMs(bucket, run, durationMs) {
-	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
-	if (!bucket || bucket.coldRuns <= 0) return 0;
-	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
-}
-function isHit(cacheHit) {
-	return cacheHit === "local" || cacheHit === "remote";
-}
-function wholeMs(value) {
-	const ms = Number(value);
-	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
-}
-//#endregion
-//#region src/engine/build-detail.ts
-const LINE_MAX = 160;
-const TARGET_GRAPH = /^note: Target dependency graph \((\d+) targets?\)/;
-const XCODE_ACTION = /^([A-Z][A-Za-z]+)\s(.*)\s\(in target '([^']+)' from project '([^']+)'\)$/;
-const XCODE_CONFIGURE = /^(ComputeTargetDependencyGraph|CreateBuildDescription|CreateBuildRequest|Resolve Package Graph|Prepare packages)$/;
-const GRADLE_TASK = /^> Task (:\S+)/;
-/**
-* xcodebuild actions that end a target's work: a clean build touches each product last, and an incremental build
-* that touches nothing still signs framework products last. Targets that end any other way are not counted.
-*/
-const XCODE_TARGET_DONE = /^(Touch|RegisterExecutionPolicyException|CodeSign)$/;
-const GRADLE_CONFIGURE = /^> Configure project /;
-/**
-* SwiftPM prints `[done / total] name` once it plans the build (with U+2009 thin spaces around the slash in Swift 6.4
-* output), `[done/total] Compiling ...` in older toolchains; Swift 6.4 names the target being worked on, and
-* `<product>-product` is the link of a product.
-*/
-const SWIFTPM_PROGRESS = /^\[(\d+)\s*\/\s*(\d+)\](?:\s+(.*))?$/;
-const SWIFTPM_CONFIGURE = /^(Fetching|Fetched|Computing version|Computed|Creating working copy|Working copy of)\b|^\[(Pre-planning|Planning|Using on-disk description)/;
-const XCODE_STEPS = [
-	[/^(CpResource|CopyPNGFile|CopyStringsFile|CompileAssetCatalog\w*|CompileStoryboard|CompileXIB|LinkStoryboards|ProcessInfoPlistFile)$/, "resources"],
-	[/^(Compile\w*|Swift\w*|ScanDependencies|Precompile\w*)$/, "compile"],
-	[/^(Ld|Libtool|CreateUniversalBinary|GenerateDSYMFile)$/, "link"],
-	[/^PhaseScriptExecution$/, "script"],
-	[/^CodeSign$/, "sign"]
-];
-const GRADLE_STEPS = [
-	[/[Dd]ex/, "dex"],
-	[/^(createBundle\w*JsAndAssets|generateCodegen\w*)$/, "script"],
-	[/(Resources?|Assets|Manifest|ResValues|RFile|JavaRes)$/, "resources"],
-	[/^(compile|kapt|ksp|javaPreCompile|buildCMake|configureCMake|externalNativeBuild)/, "compile"],
-	[/^(package|assemble|install|zipalign|validateSigning|merge\w*NativeLibs|strip\w*Symbols)/, "package"]
-];
-function stepOf(name, table) {
-	return table.find(([pattern]) => pattern.test(name))?.[1] ?? null;
-}
-function clip(text) {
-	return text.length > LINE_MAX ? `${text.slice(0, 157)}...` : text;
-}
-function unescape(token) {
-	return token.replace(/\\(.)/g, "$1");
-}
-function baseName(path) {
-	return path.split("/").findLast(Boolean) ?? path;
-}
-/**
-* An xcodebuild action line in short form: the action, the file it works on and its target, as in
-* `CompileC sqlite3.c (sqlite3)`. The file is the last absolute path in the arguments, which xcodebuild prints
-* as the source for compile, copy and plist steps and as the product for link and sign steps; a script phase
-* shows its name instead.
-*/
-function shortXcodeAction(action, args, target) {
-	const tokens = args.match(/(?:\\.|\S)+/g) ?? [];
-	const subject = action === "PhaseScriptExecution" ? unescape(tokens[0] ?? "") : baseName(unescape(tokens.findLast((token) => token.startsWith("/")) ?? ""));
-	return clip(`${action}${subject ? ` ${subject}` : ""} (${target})`);
-}
-function swiftpmStep(text) {
-	return /^Linking\b|-product$/.test(text) ? "link" : "compile";
-}
-/** What one line of xcodebuild, Gradle or SwiftPM output says about the build's progress, or null for any other line. */
-function parseBuildToolLine(msg) {
-	const counted = SWIFTPM_PROGRESS.exec(msg);
-	if (counted) {
-		const text = counted[3]?.trim() ?? "";
-		return {
-			kind: "count",
-			done: Number(counted[1]),
-			total: Number(counted[2]),
-			step: swiftpmStep(text),
-			line: text ? clip(text) : null
-		};
-	}
-	if (SWIFTPM_CONFIGURE.test(msg)) return { kind: "configure" };
-	const graph = TARGET_GRAPH.exec(msg);
-	if (graph) return {
-		kind: "total",
-		unit: "targets",
-		total: Number(graph[1])
-	};
-	if (XCODE_CONFIGURE.test(msg) || GRADLE_CONFIGURE.test(msg)) return { kind: "configure" };
-	const action = XCODE_ACTION.exec(msg);
-	if (action) {
-		const [, name, args, target, project] = action;
-		const step = stepOf(name, XCODE_STEPS);
-		return {
-			kind: "unit",
-			unit: "targets",
-			id: `${project}/${target}`,
-			step,
-			line: step ? shortXcodeAction(name, args, target) : null,
-			finished: XCODE_TARGET_DONE.test(name)
-		};
-	}
-	const task = GRADLE_TASK.exec(msg);
-	if (task) {
-		const path = task[1];
-		return {
-			kind: "unit",
-			unit: "tasks",
-			id: path,
-			step: stepOf(path.slice(path.lastIndexOf(":") + 1), GRADLE_STEPS),
-			line: clip(`> Task ${path}`),
-			finished: false
-		};
-	}
-	return null;
-}
-/**
-* Accumulates a build's tool output into its detail: xcodebuild counts the distinct targets it finished against the
-* total its dependency graph note gives; Gradle counts the task lines it printed and has no total; SwiftPM reports
-* its own `[done / total]` counts, which the parser passes through.
-*/
-function createBuildDetailParser() {
-	let seen = false;
-	let step = null;
-	let unit = null;
-	let total = null;
-	let line = null;
-	let tasks = 0;
-	let counted = null;
-	const targets = /* @__PURE__ */ new Set();
-	return {
-		push(msg) {
-			const parsed = parseBuildToolLine(msg);
-			if (!parsed) return false;
-			seen = true;
-			if (parsed.kind === "total") {
-				unit = "targets";
-				total = parsed.total;
-				return true;
-			}
-			if (parsed.kind === "configure") {
-				step = "configure";
-				return true;
-			}
-			if (parsed.kind === "count") {
-				unit = "steps";
-				counted = {
-					done: parsed.done,
-					total: parsed.total
-				};
-				step = parsed.step;
-				if (parsed.line) line = parsed.line;
-				return true;
-			}
-			unit = parsed.unit;
-			if (parsed.unit === "tasks") tasks += 1;
-			else if (parsed.finished) targets.add(parsed.id);
-			if (parsed.step) step = parsed.step;
-			if (parsed.line) line = parsed.line;
-			return true;
-		},
-		detail(updatedAt) {
-			if (!seen) return null;
-			if (unit === "steps" && counted) return {
-				step,
-				unit,
-				done: Math.min(counted.done, counted.total),
-				total: counted.total,
-				line,
-				updatedAt
-			};
-			const done = unit === "tasks" ? tasks : unit === "targets" ? targets.size : null;
-			return {
-				step,
-				unit,
-				done: done !== null && total !== null ? Math.min(done, total) : done,
-				total: unit === "tasks" ? null : total,
-				line,
-				updatedAt
-			};
-		}
-	};
-}
-//#endregion
-//#region src/engine/build-progress.ts
-const ACTIVE_BUILD_KEY = "activeBuild";
-const NO_BUILD_PROGRESS = {
-	step: () => {},
-	activity: () => {},
-	estimate: () => {},
-	miss: () => {},
-	hit: () => {},
-	deviceSetup: () => {},
-	deviceSetupKnown: () => void 0,
-	place: () => {},
-	waitingOn: () => {},
-	waitingFor: () => {},
-	output: () => {},
-	durations: () => ({}),
-	steps: () => null,
-	clear: () => {}
-};
-/** `writer`, with each record it writes also passed to `progress.output`. */
-function tapBuildLog(writer, progress) {
-	if (progress === NO_BUILD_PROGRESS) return writer;
-	return {
-		get file() {
-			return writer.file;
-		},
-		write(record) {
-			progress.output(record);
-			return writer.write(record);
-		},
-		close: () => writer.close(),
-		get written() {
-			return writer.written;
-		},
-		get dropped() {
-			return writer.dropped;
-		},
-		get lastError() {
-			return writer.lastError;
-		}
-	};
-}
-const DETAIL_WRITE_MS = 2e3;
-function toolLine(record) {
-	if (!record || typeof record !== "object") return null;
-	const { src, level, msg } = record;
-	return src === "build" && level === "debug" && typeof msg === "string" ? msg : null;
-}
-function writeBuildDetail(root, claimId, detail) {
-	const file = workspaceBuildDetailFile(root);
-	const tmp = `${file}.tmp-${process.pid}`;
-	mkdirSync(dirname(file), { recursive: true });
-	writeFileSync(tmp, JSON.stringify({
-		claimId,
-		detail
-	}));
-	renameSync(tmp, file);
-}
-const COLD_PHASES = [
-	"prebuild",
-	"pods",
-	"compile"
-];
-const HIT_PHASES = ["install", "launch"];
-function settledOutcome(phase, entered) {
-	if (COLD_PHASES.includes(phase)) return "cold";
-	if (phase === "device") return entered.some((entry) => entry.phase === "cache-lookup") ? "hit" : null;
-	return HIT_PHASES.includes(phase) ? "hit" : null;
-}
-function projectHistory(projectKey) {
-	try {
-		return readStats$1().record?.history?.[projectKey];
-	} catch {
-		return;
-	}
-}
-function startBuildProgress({ root, platform, slot, claim, now = Date.now, note = () => {} }) {
-	const startedAt = new Date(now()).toISOString();
-	const record = {
-		platform,
-		slot,
-		startedAt,
-		phase: "prepare",
-		phaseStartedAt: startedAt,
-		phases: [{
-			phase: "prepare",
-			startedAt
-		}],
-		claim: {
-			root: claim.root,
-			path: claim.path,
-			claimId: claim.claimId,
-			pid: claim.owner.pid
-		}
-	};
-	let warned = false;
-	const guard = (fn) => {
-		try {
-			fn();
-		} catch (error) {
-			if (warned) return;
-			warned = true;
-			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
-		}
-	};
-	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
-		...before(state),
-		[ACTIVE_BUILD_KEY]: record
-	})));
-	write(withInterruptedBuild);
-	let projectKey = null;
-	const parser = createBuildDetailParser();
-	let detailWrittenAt = -Infinity;
-	let detailTimer = null;
-	const flushDetail = () => {
-		detailTimer = null;
-		detailWrittenAt = now();
-		const detail = parser.detail(new Date(detailWrittenAt).toISOString());
-		if (detail) guard(() => writeBuildDetail(root, record.claim.claimId, detail));
-	};
-	const settle = (outcome) => {
-		record.outcome = outcome;
-		if (projectKey && platform !== "macos") record.estimate = estimateBuild(projectHistory(projectKey), platform, outcome, record.deviceSetup);
-	};
-	const waits = /* @__PURE__ */ new Map();
-	return {
-		step(phase) {
-			if (phase === record.phase) return;
-			const at = new Date(now()).toISOString();
-			record.phase = phase;
-			record.phaseStartedAt = at;
-			record.phases.push({
-				phase,
-				startedAt: at
-			});
-			if (phase !== "wait") delete record.waitingOn;
-			delete record.activity;
-			const outcome = record.outcome || platform === "macos" ? null : settledOutcome(phase, record.phases);
-			if (outcome) settle(outcome);
-			write();
-		},
-		activity(name, at) {
-			if ((record.activity?.name ?? null) === name) return;
-			if (name) record.activity = {
-				name,
-				startedAt: new Date(at ?? now()).toISOString()
-			};
-			else delete record.activity;
-			write();
-		},
-		estimate(key) {
-			if (platform === "macos") return;
-			projectKey = key;
-			record.estimate = estimateBuild(projectHistory(key), platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
-			write();
-		},
-		miss(reason, provisional = false) {
-			record.missReason = reason;
-			settle("cold");
-			if (provisional) record.missProvisional = true;
-			else delete record.missProvisional;
-			write();
-		},
-		hit() {
-			delete record.missReason;
-			delete record.missProvisional;
-			settle("hit");
-			write();
-		},
-		deviceSetup(setup) {
-			if (setup === void 0) return;
-			record.deviceSetup = setup;
-			write();
-		},
-		deviceSetupKnown() {
-			return record.deviceSetup;
-		},
-		place(remote) {
-			const current = record.placement;
-			if (!remote) {
-				if (!current) return;
-				delete record.placement;
-				return write();
-			}
-			if (current?.host === remote.host && current.phase === remote.phase) return;
-			const at = new Date(now()).toISOString();
-			record.placement = {
-				host: remote.host,
-				phase: remote.phase,
-				startedAt: current?.host === remote.host ? current.startedAt : at,
-				phaseStartedAt: at
-			};
-			write();
-		},
-		waitingFor(info, kind) {
-			if (info) waits.set(info.kind, info);
-			else if (kind) waits.delete(kind);
-			else waits.clear();
-			const first = [...waits.values()].toSorted((a, b) => Date.parse(a.since) - Date.parse(b.since))[0];
-			if (first) record.waitingFor = first;
-			else delete record.waitingFor;
-			write();
-		},
-		waitingOn(holder) {
-			if (holder === null) {
-				if (!record.waitingOn) return;
-				delete record.waitingOn;
-			} else {
-				if (record.waitingOn?.path === holder) return;
-				record.waitingOn = { path: holder };
-			}
-			write();
-		},
-		output(line) {
-			const msg = toolLine(line);
-			if (msg === null || !parser.push(msg) || detailTimer) return;
-			const wait = detailWrittenAt + DETAIL_WRITE_MS - now();
-			if (wait <= 0) return flushDetail();
-			detailTimer = setTimeout(flushDetail, wait);
-			detailTimer.unref?.();
-		},
-		durations() {
-			return phaseDurations(record.phases, now());
-		},
-		steps() {
-			const detail = parser.detail("");
-			return detail?.unit === "steps" ? detail.total : null;
-		},
-		clear() {
-			if (detailTimer) clearTimeout(detailTimer);
-			detailTimer = null;
-			guard(() => rmSync(workspaceBuildDetailFile(root), { force: true }));
-			guard(() => {
-				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
-			});
-		}
-	};
-}
-function phaseDurations(phases, now) {
-	const out = {};
-	phases.forEach(({ phase, startedAt }, index) => {
-		const start = Date.parse(startedAt);
-		const next = phases[index + 1];
-		const end = next ? Date.parse(next.startedAt) : now;
-		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
-		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
-	});
-	return out;
-}
-function completedPhaseDurations(phases) {
-	if (phases.length < 2) return void 0;
-	const durations = phaseDurations(phases.slice(0, -1), Date.parse(phases.at(-1).startedAt));
-	return Object.keys(durations).length ? durations : void 0;
-}
-const HISTORY_FIELDS = [
-	"devicePlacement",
-	"platform",
-	"status",
-	"configuration",
-	"fingerprint",
-	"cacheKey",
-	"cacheHit",
-	"cacheSkipped",
-	"durationMs",
-	"startedAt",
-	"errorCode",
-	"missReason",
-	"buildMachine",
-	"builtOn",
-	"offloadedTo",
-	"offloadFallback",
-	"diagnostics",
-	"compileSteps"
-];
-function withHistoryEntry(state, platform, entry) {
-	const saved = state[BUILD_HISTORY_KEY];
-	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
-	const list = Array.isArray(history[platform]) ? history[platform] : [];
-	return {
-		...state,
-		[BUILD_HISTORY_KEY]: {
-			...history,
-			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
-		}
-	};
-}
-function finishedResult(record) {
-	if (record.status === "ok") return "succeeded";
-	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
-}
-function recordFinishedBuild(root, record, { update = updateWorkspaceState, now = Date.now, artifactOnly = false } = {}) {
-	const platform = record.platform;
-	update(root, (state) => {
-		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
-		const own = active?.platform === platform ? active : null;
-		const entry = {
-			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
-			result: finishedResult(record),
-			slot: own?.slot ?? "default",
-			phases: own ? phaseDurations(own.phases, now()) : {}
-		};
-		if (artifactOnly || platform === "macos") return withHistoryEntry(state, platform, entry);
-		const slot = own?.slot ?? "default";
-		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
-		const savedSlot = isJsonObject(slots[slot]) ? slots[slot] : {};
-		const savedDevice = slot === "default" ? state[platform] : savedSlot[platform];
-		if (record.devicePlacement || isJsonObject(savedDevice)) {
-			const device = isJsonObject(savedDevice) ? { ...savedDevice } : {};
-			if (record.devicePlacement) device.devicePlacement = record.devicePlacement;
-			else delete device.devicePlacement;
-			state = slot === "default" ? {
-				...state,
-				[platform]: device
-			} : {
-				...state,
-				deviceSlots: {
-					...slots,
-					[slot]: {
-						...savedSlot,
-						[platform]: device
-					}
-				}
-			};
-		}
-		return withHistoryEntry({
-			...state,
-			lastBuild: record,
-			[LAST_BUILD_KEYS[platform]]: record
-		}, platform, entry);
-	});
-}
-/** Adds one phase's duration to the recorded run of `platform` that started at `startedAt`. */
-function recordBuildPhase(root, platform, startedAt, phase, ms) {
-	updateWorkspaceState(root, (state) => {
-		const saved = state[BUILD_HISTORY_KEY];
-		const list = isJsonObject(saved) && Array.isArray(saved[platform]) ? saved[platform] : [];
-		const index = list.findIndex((entry) => isJsonObject(entry) && entry.startedAt === startedAt);
-		const entry = list[index];
-		if (!isJsonObject(entry)) return state;
-		const phases = isJsonObject(entry.phases) ? entry.phases : {};
-		const next = [...list];
-		next[index] = {
-			...entry,
-			phases: {
-				...phases,
-				[phase]: Math.round(ms)
-			}
-		};
-		return {
-			...state,
-			[BUILD_HISTORY_KEY]: {
-				...saved,
-				[platform]: next
-			}
-		};
-	});
-}
-function withInterruptedBuild(state) {
-	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
-	if (!left) return state;
-	const last = state[BUILD_HISTORY_KEY]?.[left.platform]?.[0];
-	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
-	return withHistoryEntry(state, left.platform, {
-		platform: left.platform,
-		status: "failed",
-		result: "interrupted",
-		slot: left.slot,
-		configuration: null,
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		cacheSkipped: false,
-		durationMs: null,
-		startedAt: left.startedAt,
-		phases: {
-			...phaseDurations(left.phases, Date.parse(left.phaseStartedAt)),
-			[left.phase]: 0
-		}
-	});
-}
-function parseActiveBuild(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const record = value;
-	const claim = record.claim;
-	if (record.platform !== "ios" && record.platform !== "android" && record.platform !== "macos") return null;
-	if (!isPhase(record.phase)) return null;
-	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
-	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
-	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
-	const missReason = parseMissReason(record.missReason);
-	const placement = parsePlacement(record.placement);
-	const waitingOn = parseWaitingOn(record.waitingOn);
-	const waitingFor = parseWaitingFor(record.waitingFor);
-	const estimate = parseEstimate(record.estimate);
-	const activity = parseActivity(record.activity);
-	return {
-		platform: record.platform,
-		slot: typeof record.slot === "string" ? record.slot : "default",
-		startedAt: record.startedAt,
-		phase: record.phase,
-		phaseStartedAt: record.phaseStartedAt,
-		phases,
-		...missReason ? { missReason } : {},
-		...missReason && record.missProvisional === true ? { missProvisional: true } : {},
-		...placement ? { placement } : {},
-		...waitingOn ? { waitingOn } : {},
-		...waitingFor ? { waitingFor } : {},
-		...typeof record.deviceSetup === "boolean" ? { deviceSetup: record.deviceSetup } : {},
-		...record.outcome === "hit" || record.outcome === "cold" ? { outcome: record.outcome } : {},
-		...estimate ? { estimate } : {},
-		...activity ? { activity } : {},
-		claim: {
-			root: claim.root,
-			path: typeof claim.path === "string" ? claim.path : "",
-			claimId: claim.claimId,
-			pid: typeof claim.pid === "number" ? claim.pid : 0
-		}
-	};
-}
-function parsePlacement(value) {
-	if (!value || typeof value !== "object") return null;
-	const { host, phase, startedAt, phaseStartedAt } = value;
-	if ([
-		host,
-		phase,
-		startedAt,
-		phaseStartedAt
-	].some((field) => typeof field !== "string")) return null;
-	return {
-		host,
-		phase,
-		startedAt,
-		phaseStartedAt
-	};
-}
-function parseWaitingFor(value) {
-	if (!value || typeof value !== "object") return null;
-	const { kind, inUse, max, since } = value;
-	if (kind !== "build-slot" && kind !== "device-slot") return null;
-	if (!Number.isInteger(inUse) || inUse < 0 || !Number.isInteger(max) || max <= 0) return null;
-	if (typeof since !== "string" || !Number.isFinite(Date.parse(since))) return null;
-	return {
-		kind,
-		inUse,
-		max,
-		since
-	};
-}
-function parseActivity(value) {
-	if (!value || typeof value !== "object") return null;
-	const { name, startedAt } = value;
-	if (name !== "booting" && name !== "bundling" && name !== "waiting-ready") return null;
-	return typeof startedAt === "string" ? {
-		name,
-		startedAt
-	} : null;
-}
-function parseWaitingOn(value) {
-	const path = value?.path;
-	return typeof path === "string" && path ? { path } : null;
-}
-function parseEstimate(value) {
-	if (!value || typeof value !== "object") return null;
-	const { outcome, expectedMs, basis, phaseMs, planned } = value;
-	if (outcome !== null && outcome !== "hit" && outcome !== "cold") return null;
-	if (expectedMs !== null && typeof expectedMs !== "number") return null;
-	if (typeof basis !== "number" || !Array.isArray(planned) || !phaseMs || typeof phaseMs !== "object") return null;
-	const durations = Object.entries(phaseMs).filter((entry) => isPhase(entry[0]) && typeof entry[1] === "number");
-	return {
-		outcome,
-		expectedMs,
-		basis,
-		phaseMs: Object.fromEntries(durations),
-		planned: planned.filter(isPhase)
-	};
-}
-function isPhase(value) {
-	return BUILD_PHASES.includes(value);
-}
-function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
-	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
-	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
-	return survey.unresolved.length ? "unknown" : "stale";
-}
-function median(values) {
-	if (!values.length) return null;
-	const sorted = values.toSorted((a, b) => a - b);
-	const mid = Math.floor(sorted.length / 2);
-	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
-}
-function estimateBuild(history, platform, known, deviceSetup) {
-	const lists = platform === "macos" ? void 0 : history?.[platform];
-	const outcome = known ?? latestOutcome(lists);
-	const samples = matchDeviceSetup(outcome && lists?.[outcome] || [], deviceSetup);
-	const phaseMs = {};
-	const planned = [];
-	for (const phase of BUILD_PHASES) {
-		const durations = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
-		const ms = median(durations);
-		if (ms === null) continue;
-		phaseMs[phase] = ms;
-		if (durations.length * 2 >= samples.length) planned.push(phase);
-	}
-	return {
-		outcome,
-		expectedMs: median(samples.map((sample) => sample.durationMs)),
-		basis: samples.length,
-		phaseMs,
-		planned
-	};
-}
-const MIN_TAGGED_SAMPLES = 3;
-function matchDeviceSetup(samples, deviceSetup) {
-	if (deviceSetup === void 0) return samples;
-	const tagged = samples.filter((sample) => sample.deviceSetup === deviceSetup);
-	if (deviceSetup || tagged.length >= MIN_TAGGED_SAMPLES) return tagged;
-	return samples.filter((sample) => sample.deviceSetup !== true);
-}
-function latestOutcome(lists) {
-	let latest = null;
-	for (const outcome of ["hit", "cold"]) {
-		const last = lists?.[outcome]?.at(-1);
-		const at = last ? Date.parse(last.at) : NaN;
-		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
-			outcome,
-			at
-		};
-	}
-	return latest?.outcome ?? null;
-}
-function buildReport(record, { state, history }) {
-	const estimate = record.estimate ?? estimateBuild(history, record.platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
-	const plannedPhases = estimate.planned.flatMap((phase) => {
-		const expectedMs = estimate.phaseMs[phase];
-		return expectedMs === void 0 ? [] : [{
-			phase,
-			expectedMs
-		}];
-	});
-	const completedPhaseMs = completedPhaseDurations(record.phases);
-	return {
-		platform: record.platform,
-		slot: record.slot,
-		state,
-		phase: record.phase,
-		startedAt: record.startedAt,
-		phaseStartedAt: record.phaseStartedAt,
-		outcome: estimate.outcome,
-		outcomeKnown: record.outcome !== void 0,
-		...record.outcome && record.phases.some(({ phase }) => phase === "cache-lookup") ? { cacheLookupOutcome: record.outcome === "hit" ? "hit" : "miss" } : {},
-		expectedMs: estimate.expectedMs,
-		expectedPhaseMs: estimate.phaseMs[record.phase] ?? null,
-		...completedPhaseMs ? { completedPhaseMs } : {},
-		basis: estimate.basis,
-		plannedPhases: plannedPhases.length ? plannedPhases : null,
-		...record.missReason ? { missReason: record.missReason } : {},
-		...record.missReason && record.missProvisional ? { missProvisional: true } : {},
-		placement: record.placement ?? "local",
-		...record.waitingOn ? { waitingOn: record.waitingOn } : {},
-		...record.waitingFor ? { waitingFor: record.waitingFor } : {},
-		...record.activity ? { activity: { ...record.activity } } : {}
-	};
-}
-/**
-* The run's `bundling` activity with Metro's percent, when the request Metro reports in flight is the one the activity
-* started on: same platform and same start, since both come from the request's `bundle_response_started` record.
-*/
-function bundlingActivity(activity, platform, bundle) {
-	if (activity?.name !== "bundling" || !bundle?.bundling || bundle.percent === void 0) return activity;
-	if (bundle.platform !== platform || bundle.startedAt !== activity.startedAt) return activity;
-	return {
-		...activity,
-		percent: bundle.percent
-	};
-}
-function remainingText(remainingMs) {
-	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
-}
-function activityText({ name, percent, startedAt }, now) {
-	return `${name === "booting" ? "booting" : name === "waiting-ready" ? "waiting for app ready" : percent === void 0 ? "bundling JS" : `bundling JS ${percent}%`}, ${formatElapsed(Math.max(0, now - Date.parse(startedAt)))}`;
-}
-function buildStatusLine(report, now) {
-	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
-	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
-	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
-	const remote = typeof report.placement === "object" ? ` on ${report.placement.host} (${report.placement.phase}, ${formatElapsed(Math.max(0, now - Date.parse(report.placement.phaseStartedAt)))})` : "";
-	const waiting = report.waitingOn ? ` on ${report.waitingOn.path}` : "";
-	const activity = report.activity ? ` (${activityText(report.activity, now)})` : "";
-	const head = `build: ${report.platform}${slot} ${report.phase}${activity}${waiting}${remote}, ${formatElapsed(elapsedMs)} elapsed`;
-	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
-	if (report.expectedMs === null) return head;
-	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
-	const remainingMs = report.expectedMs - elapsedMs;
-	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
-}
-//#endregion
-//#region src/supervisor/stop-cause.ts
-function requestDevServerStop(root, processToken, requester) {
-	if (!processToken) return;
-	try {
-		writeWorkspaceState(root, { [DEV_SERVER_STOP_REQUEST_KEY]: {
-			processToken,
-			by: requester.by,
-			pid: process.pid,
-			at: (/* @__PURE__ */ new Date()).toISOString(),
-			...requester.workspace ? { workspace: requester.workspace } : {}
-		} });
-	} catch {}
-}
-function withdrawDevServerStopRequest(root, processToken) {
-	if (!processToken) return;
-	try {
-		clearWorkspaceStateKey(root, DEV_SERVER_STOP_REQUEST_KEY, (value) => {
-			return readDevServerStopRequest({ [DEV_SERVER_STOP_REQUEST_KEY]: value })?.processToken === processToken;
-		});
-	} catch {}
-}
-function devServerStopRecord(trigger, request, at) {
-	if (request) return {
-		reason: "requested",
-		at,
-		by: request.by,
-		byPid: request.pid,
-		...request.workspace ? { byWorkspace: request.workspace } : {}
-	};
-	return trigger.kind === "signal" ? {
-		reason: "signal",
-		at,
-		signal: trigger.signal
-	} : {
-		reason: "server-exited",
-		at,
-		mode: trigger.mode,
-		code: trigger.code,
-		signal: trigger.signal
-	};
-}
-function describeDevServerStop(record) {
-	if (record.reason === "idle") return `idle for ${record.idleMinutes} minutes (metro.idleStopMinutes)`;
-	if (record.reason === "requested") return `stop requested by ${record.by} (pid ${record.byPid}${record.byWorkspace ? ` in ${record.byWorkspace}` : ""})`;
-	if (record.reason === "signal") return `received ${record.signal} with no Stim stop request recorded, so it likely came from outside Stim`;
-	const detail = record.signal ? `signal ${record.signal}` : `exit code ${record.code ?? "unknown"}`;
-	const expoSignal = record.mode === "expo-child" && record.code === 0 ? "; Expo CLI also exits 0 on SIGTERM, and no Stim stop request was recorded" : "";
-	return `the ${record.mode} dev server exited unexpectedly (${detail})${expoSignal}`;
-}
-function devServerStopLevel(record) {
-	if (record.reason === "server-exited") return "error";
-	return record.reason === "signal" ? "warn" : "info";
-}
-/** The log line for a recorded supervisor whose process is proven gone, or null while it may still run. */
-function vanishedSupervisorMessage(record) {
-	if (!record || typeof record.pid !== "number") return null;
-	const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
-	if (identity !== "gone" && identity !== "different") return null;
-	const started = typeof record.startedAt === "string" ? ` (started ${record.startedAt})` : "";
-	return `supervisor pid ${record.pid}${started} ${VANISHED}`;
-}
-const VANISHED = "is gone and recorded no cause: usually SIGKILL, a crash or a machine restart";
-function logVanishedSupervisor(root, record) {
-	const msg = vanishedSupervisorMessage(record);
-	if (!msg) return;
-	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
-	writer.write({
-		src: "metro",
-		level: "warn",
-		event: "supervisor_vanished",
-		msg
-	});
-	writer.close();
-}
-/** The recorded stop, else a vanished supervisor when status proved the recorded one gone. */
-function metroLastStop(state, supervisor) {
-	const recorded = readDevServerStop(state);
-	if (recorded) return recorded;
-	if (supervisor?.status !== "stale" || typeof supervisor.pid !== "number") return null;
-	const startedAt = typeof supervisor.startedAt === "string" ? supervisor.startedAt : null;
-	return {
-		reason: "vanished",
-		pid: supervisor.pid,
-		startedAt
-	};
-}
-function describeMetroLastStop(stop) {
-	return stop.reason === "vanished" ? `supervisor pid ${stop.pid} ${VANISHED}` : describeDevServerStop(stop);
-}
-//#endregion
-//#region src/supervisor/cache-reset.ts
-async function stopOwnedMetro(root, requester) {
-	const project = getProject(root);
-	const port = project?.metroPort;
-	const target = resolveSupervisorTarget({
-		state: readWorkspaceState$1(root)?.supervisor,
-		record: project?.supervisor,
-		reservedPort: port
-	});
-	if (target.status === "unverified") return {
-		status: "unverified",
-		reason: target.reason ?? "unknown identity"
-	};
-	if (port && target.status !== "ours" && !(await resolveProjectMetro(port, root)).missing) return {
-		status: "external",
-		reason: `a dev server Stim did not start answers on port ${port}`
-	};
-	if (target.status !== "ours") return { status: "not-running" };
-	const expected = {
-		pid: target.pid,
-		processToken: target.processToken
-	};
-	requestDevServerStop(root, target.processToken, requester);
-	const signalled = killMetroTree(target.pid, target.processToken);
-	if (!signalled) withdrawDevServerStopRequest(root, target.processToken);
-	if (!signalled || !await (0, process_identity_exports.waitForProcessExit)(expected, 1e4)) return {
-		status: "stuck",
-		reason: `supervisor pid ${target.pid} did not exit`
-	};
-	if (port && !(await resolveProjectMetro(port, root)).missing) return {
-		status: "port-occupied",
-		reason: `port ${port} is still occupied after stopping Metro`
-	};
-	clearWorkspaceSupervisor(root, expected);
-	clearSupervisor(root, expected);
-	return { status: "stopped" };
-}
-async function stopOwnedMetroForReset(root) {
-	const stopped = await stopOwnedMetro(root, { by: "stim start --reset-cache" });
-	switch (stopped.status) {
-		case "unverified": throw supervisorError("STIM_SUPERVISOR_EXITED", `Cannot reset Metro: ${stopped.reason}.`, "Stop it with the tool that started it, then retry. Stim leaves unverified processes alone.");
-		case "external": throw supervisorError("STIM_SUPERVISOR_EXITED", "Cannot reset an externally started dev server.", "Stop it with the tool that started it, then retry `stim start --reset-cache`.");
-		case "stuck": throw supervisorError("STIM_SUPERVISOR_EXITED", "The owned Metro supervisor could not be stopped for a cache reset.", "Inspect `stim status` and `stim logs`, then retry. No cache reset was recorded.");
-		case "port-occupied": throw supervisorError("STIM_SUPERVISOR_EXITED", `Port ${getProject(root)?.metroPort} is still occupied after stopping Metro.`, "Inspect the listener before retrying. Stim does not terminate unrecorded processes.");
-	}
-}
-//#endregion
-//#region src/cache/caches.ts
-function xcodeDerivedDataRoot() {
-	return join$1(homedir(), "Library", "Developer", "Xcode", "DerivedData");
-}
-function compilationCache() {
-	const dir = join$1(xcodeDerivedDataRoot(), "CompilationCache.noindex");
-	if (!existsSync$1(dir)) return null;
-	return {
-		name: "Xcode compilation cache",
-		dir,
-		prune: "atomic",
-		note: "index-backed, so it can only be emptied whole"
-	};
-}
-function gradleBuildCache() {
-	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir(), ".gradle");
-	const dir = resolve$1(gradleHome, "caches", "build-cache-1");
-	if (!existsSync$1(dir)) return null;
-	return {
-		name: "Gradle build cache",
-		dir,
-		prune: "report-only",
-		note: "shared with every Gradle build; report only, never pruned or emptied by Stim"
-	};
-}
-function metroFileMaps() {
-	const root = tmpdir();
-	if (!existsSync$1(root)) return null;
-	let names;
-	try {
-		names = readdirSync$1(root).filter((n) => n.startsWith("metro-file-map-"));
-	} catch {
-		return null;
-	}
-	const uid = process.getuid?.();
-	const files = [];
-	let bytes = 0;
-	for (const n of names) try {
-		const st = statSync$1(join$1(root, n));
-		if (uid !== void 0 && st.uid !== uid) continue;
-		files.push(join$1(root, n));
-		bytes += st.size;
-	} catch {}
-	if (!files.length) return null;
-	return {
-		name: "Metro file maps",
-		dir: root,
-		files,
-		bytes,
-		prune: "entries",
-		note: `${files.length} file(s), one per project root Metro has served`
-	};
-}
-function discoverCaches() {
-	const gradle = gradleBuildCache();
-	const gradleDir = gradle ? canonicalCacheDir(gradle.dir) : null;
-	const registered = protectNestedMetroAncestors(suppressLegacyMetroAncestors(registeredCaches().map((c) => Object.assign({}, c, {
-		name: c.name ?? c.dir,
-		note: c.note ?? "registered",
-		prune: c.prune,
-		source: "registered"
-	}))));
-	const detected = [
-		compilationCache(),
-		gradle,
-		metroFileMaps()
-	].filter((c) => Boolean(c)).map((c) => Object.assign({}, c, { source: "detected" }));
-	return distinguishSharedNames(mergeCacheDescriptors([...registered, ...detected], gradleDir));
-}
-function distinguishSharedNames(caches) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const cache of caches) counts.set(cache.name, (counts.get(cache.name) ?? 0) + 1);
-	const labelled = caches.map((cache) => (counts.get(cache.name) ?? 0) < 2 ? cache : Object.assign({}, cache, { name: `${cache.name}: ${basename$1(cache.dir) || cache.dir}` }));
-	const labels = /* @__PURE__ */ new Map();
-	for (const cache of labelled) labels.set(cache.name, (labels.get(cache.name) ?? 0) + 1);
-	return labelled.map((cache, i) => (labels.get(cache.name) ?? 0) < 2 || cache === caches[i] ? cache : Object.assign({}, cache, { name: `${caches[i].name}: ${cache.dir}` }));
-}
-function suppressLegacyMetroAncestors(caches) {
-	const current = caches.filter(isCurrentMetroStore);
-	return caches.filter((cache) => {
-		if (!isLegacyMetroStore(cache)) return true;
-		return !current.some((candidate) => isNamedMetroChild(cache.dir, candidate.dir));
-	});
-}
-function protectNestedMetroAncestors(caches) {
-	const current = caches.filter(isCurrentMetroStore);
-	return caches.map((cache) => {
-		if (!isCurrentMetroStore(cache)) return cache;
-		if (!current.some((candidate) => isNamedMetroChild(cache.dir, candidate.dir))) return cache;
-		return Object.assign({}, cache, {
-			prune: "report-only",
-			note: "named Metro store is also an override parent; report only while its child is registered"
-		});
-	});
-}
-function isLegacyMetroStore(cache) {
-	return isMetroStore(cache) && cache.layout === void 0;
-}
-function isCurrentMetroStore(cache) {
-	return isMetroStore(cache) && cache.layout === METRO_NAMED_CACHE_LAYOUT;
-}
-function isMetroStore(cache) {
-	return cache.source === "registered" && cache.name === "Metro transform cache" && cache.prune === "entries" && cache.entriesDepth === 2;
-}
-function isNamedMetroChild(parent, candidate) {
-	const dir = canonicalCacheDir(parent);
-	const child = canonicalCacheDir(candidate);
-	return dirname$1(child) === dir || canonicalCacheDir(dirname$1(candidate)) === dir;
-}
-function mergeCacheDescriptors(caches, gradleDir) {
-	const merged = [];
-	for (const cache of caches) {
-		const descriptor = protectGradleCache(cache, gradleDir);
-		const dir = canonicalCacheDir(descriptor.dir);
-		const exact = merged.findIndex((candidate) => canonicalCacheDir(candidate.dir) === dir);
-		if (exact !== -1) {
-			const current = merged[exact];
-			if (pruneStrength(descriptor.prune) > pruneStrength(current.prune)) merged[exact] = Object.assign({}, current, {
-				prune: descriptor.prune,
-				note: descriptor.note
-			});
-			continue;
-		}
-		if (gradleDir && isGradleProtectedDescriptor(descriptor, gradleDir)) {
-			if (merged.some((candidate) => {
-				const candidateDir = canonicalCacheDir(candidate.dir);
-				return isGradleProtectedDescriptor(candidate, gradleDir) && cachePathContains(candidateDir, dir);
-			})) continue;
-			for (let i = merged.length - 1; i >= 0; i--) {
-				const candidate = merged[i];
-				const candidateDir = canonicalCacheDir(candidate.dir);
-				if (isGradleProtectedDescriptor(candidate, gradleDir) && cachePathContains(dir, candidateDir)) merged.splice(i, 1);
-			}
-		}
-		merged.push(descriptor);
-	}
-	return merged;
-}
-function protectGradleCache(cache, gradleDir) {
-	if (cache.files) return cache;
-	if (!gradleDir || !cachePathsOverlap(canonicalCacheDir(cache.dir), gradleDir)) return cache;
-	return Object.assign({}, cache, {
-		prune: "report-only",
-		note: "shared with every Gradle build; report only, never pruned or emptied by Stim"
-	});
-}
-function isGradleProtectedDescriptor(cache, gradleDir) {
-	return cache.prune === "report-only" && cachePathsOverlap(canonicalCacheDir(cache.dir), gradleDir);
-}
-function pruneStrength(prune) {
-	if (prune === "report-only") return 3;
-	if (prune === "atomic") return 2;
-	return 1;
-}
-function cachePathsOverlap(left, right) {
-	return cachePathContains(left, right) || cachePathContains(right, left);
-}
-function cachePathContains(parent, child) {
-	const rel = relative$1(parent, child);
-	return rel === "" || !rel.startsWith("..") && !isAbsolute$1(rel);
-}
-function canonicalCacheDir(dir) {
-	try {
-		return realpathSync$1(dir);
-	} catch {
-		return resolve$1(dir);
-	}
-}
-function sizeCaches(caches) {
-	return caches.map((c) => Object.assign({}, c, { bytes: c.bytes ?? directorySize(c.dir, { timeoutMs: "unbounded" }) }));
-}
-function pruneCache(cache, { olderThanDays, now = Date.now(), protect, evictBytes, byMtime = false } = {}) {
-	const cutoff = now - olderThanDays * 24 * 60 * 60 * 1e3;
-	if (cache.prune === "report-only") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "report-only shared cache; Stim never deletes it"
-	};
-	if (cache.prune === "atomic") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "index-backed; empty it whole or not at all"
-	};
-	if (!cache.files && cacheDirRefusal(cache.dir)) return {
-		removed: 0,
-		bytes: 0,
-		skipped: `${cache.dir} is not a directory this cache owns`
-	};
-	const entries = cache.files ?? entriesAtDepth(cache.dir, cache.entriesDepth ?? 1);
-	const candidates = [];
-	let protectedEntries = 0;
-	for (const entry of entries) try {
-		const st = statSync$1(entry);
-		const used = byMtime ? st.mtimeMs : Math.max(st.atimeMs, st.mtimeMs);
-		if (used >= cutoff) continue;
-		if (protect?.(entry)) {
-			protectedEntries++;
-			continue;
-		}
-		candidates.push({
-			entry,
-			used,
-			isDirectory: st.isDirectory(),
-			size: st.size
-		});
-	} catch {}
-	if (evictBytes !== void 0) candidates.sort((a, b) => a.used - b.used);
-	let removed = 0;
-	let bytes = 0;
-	let failed = 0;
-	for (const { entry, isDirectory, size } of candidates) {
-		if (evictBytes !== void 0 && bytes >= evictBytes) break;
-		try {
-			if (!existsSync$1(entry) || statSync$1(entry).mtimeMs >= cutoff) continue;
-			const entryBytes = isDirectory ? directorySize(entry, { timeoutMs: "unbounded" }) : size;
-			rmSync$1(entry, {
-				recursive: true,
-				force: true
-			});
-			removed++;
-			bytes += entryBytes;
-		} catch {
-			failed++;
-		}
-	}
-	return {
-		removed,
-		bytes,
-		failed,
-		skipped: null,
-		protectedEntries
-	};
-}
-function entriesAtDepth(dir, depth) {
-	let level = [dir];
-	for (let i = 0; i < depth; i++) {
-		const next = [];
-		for (const parent of level) {
-			let names;
-			try {
-				names = readdirSync$1(parent);
-			} catch {
-				continue;
-			}
-			for (const name of names) next.push(join$1(parent, name));
-		}
-		level = next;
-	}
-	return level;
-}
-//#endregion
-//#region src/footprint.ts
-const SOURCE = "stim-footprint.swift";
-const COMPILE_TIMEOUT_MS = 12e4;
-const READ_TIMEOUT_MS = 5e3;
-function helperSource() {
-	const here = fileURLToPath(import.meta.url);
-	if (basename(dirname(here)) === "src") return fileURLToPath(new URL(`../helper/${SOURCE}`, import.meta.url));
-	return join(dirname(here), SOURCE);
-}
-async function buildHelper() {
-	const exec = getExecutor();
-	if (!exec.runFileQuiet("xcode-select", ["-p"], { timeoutMs: READ_TIMEOUT_MS })) return null;
-	const source = helperSource();
-	try {
-		return await compiledHelper({
-			dir: join(configDir(), "helpers"),
-			name: "stim-footprint",
-			inputs: [source],
-			version: "",
-			compile: async (output) => {
-				await exec.runFileAsync("xcrun", [
-					"swiftc",
-					"-O",
-					"-swift-version",
-					"5",
-					"-o",
-					output,
-					source
-				], { timeoutMs: COMPILE_TIMEOUT_MS });
-			}
-		});
-	} catch {
-		return null;
-	}
-}
-const RETRY_BACKOFF_INITIAL_MS = 1e4;
-const RETRY_BACKOFF_MAX_MS = 6e5;
-let built = null;
-let failure = null;
-/** The `stim-footprint` helper, compiled on first use. A success is kept for the process's life; a failure retries after a doubling backoff instead of being pinned forever. */
-function footprintHelper() {
-	const home = configDir();
-	if (built?.home === home) return built.promise;
-	if (failure?.home === home && Date.now() < failure.nextRetryAt) return Promise.resolve(null);
-	const promise = buildHelper().then((helper) => {
-		if (helper === null) {
-			const backoffMs = failure?.home === home ? Math.min(failure.backoffMs * 2, RETRY_BACKOFF_MAX_MS) : RETRY_BACKOFF_INITIAL_MS;
-			failure = {
-				home,
-				nextRetryAt: Date.now() + backoffMs,
-				backoffMs
-			};
-			if (built?.promise === promise) built = null;
-			return null;
-		}
-		return helper;
-	});
-	built = {
-		home,
-		promise
-	};
-	return promise;
-}
-/** Parses the helper's `<pid> <bytes>` lines into footprint bytes by pid. */
-function parseFootprints(output) {
-	const footprints = /* @__PURE__ */ new Map();
-	for (const line of output.split("\n")) {
-		const match = /^(\d+) (\d+)$/.exec(line.trim());
-		if (match) footprints.set(Number(match[1]), Number(match[2]));
-	}
-	return footprints;
-}
-/** Every readable process's physical footprint in bytes, or null when the helper is unavailable or fails. */
-async function readFootprints() {
-	const helper = await footprintHelper();
-	const output = helper ? getExecutor().runFileQuiet(helper, [], { timeoutMs: READ_TIMEOUT_MS }) : null;
-	return output === null ? null : parseFootprints(output);
-}
-//#endregion
-//#region src/machine-usage.ts
-const SHARED = [
-	{
-		name: "CoreSimulator services",
-		pattern: /\/CoreSimulator\.framework\/|\/Simulator\.app\/Contents\/MacOS\//
-	},
-	{
-		name: "adb server",
-		pattern: /(^|\/)adb\s.*\bfork-server\b/
-	},
-	{
-		name: "Android emulator services",
-		pattern: /\/emulator\/netsimd(\s|$)/
-	},
-	{
-		name: "Gradle daemon",
-		pattern: /\borg\.gradle\.launcher\.daemon\.bootstrap\.GradleDaemon\b/
-	},
-	{
-		name: "Kotlin daemon",
-		pattern: /\bKotlinCompileDaemon\b/
-	},
-	{
-		name: "Watchman",
-		pattern: /(^|\/)watchman(\s|$)/
-	}
-];
-const STIM_SERVER_COMMAND = /(^|[\s/])stim-server(\.mjs)?(\s|$)/;
-const LAUNCHD_SIM = /^launchd_sim\s.*\/Devices\/([^/\s]+)\//;
-const MAX_DEPTH = 64;
-const EMULATOR = /(?:^|\/)(?:qemu-system-[^\s/]+|emulator)(?:\s.*)?\s(?:-avd\s+|@)(\S+)/;
-function emulatorAvd(command) {
-	return EMULATOR.exec(command)?.[1] ?? null;
-}
-function workspaceOwner(kind, env, name, id) {
-	return {
-		kind,
-		name,
-		workspace: env.path,
-		id,
-		owned: true
-	};
-}
-function rank(owner) {
-	return MACHINE_OWNER_KINDS.indexOf(owner.kind);
-}
-/**
-* Attributes every process in `processes` to at most one owner: the owner of its nearest ancestor (itself included)
-* that is a root. Roots are each booted simulator's `launchd_sim`, each emulator launcher and qemu process, and each
-* workspace's verified supervisor and Metro, running build and Chrome. Only a process under none of those falls back
-* to stim-server or a machine-wide service in `SHARED`, so a `simctl` a workspace's log collector runs stays with the
-* workspace. An emulator counts in the workspace that records its AVD whenever its process runs, including while adb
-* does not list it. A process with no root ancestor is left out. `footprints` holds physical footprint bytes by pid,
-* or is null when they could not be read, and the owners' `memoryMb` then sums resident sizes. A process missing from
-* `footprints`, another user's or one that exited between the two reads, counts its resident size.
-*/
-function attributeMachineUsage({ processes, footprints, environments, roots, simNames }) {
-	const owners = /* @__PURE__ */ new Map();
-	const rootOf = /* @__PURE__ */ new Map();
-	const fallbackOf = /* @__PURE__ */ new Map();
-	const claim = (pid, key, owner, into = rootOf) => {
-		if (!owners.has(key)) owners.set(key, owner);
-		into.set(pid, key);
-	};
-	const sims = /* @__PURE__ */ new Map();
-	const emulators = /* @__PURE__ */ new Map();
-	for (const env of environments) for (const device of [{
-		slot: "default",
-		ios: env.ios,
-		android: env.android
-	}, ...env.slots ?? []]) {
-		const slot = device.slot === "default" ? {} : { slot: device.slot };
-		if (device.ios?.state === "Booted") sims.set(device.ios.udid.toUpperCase(), {
-			kind: "simulator",
-			name: device.ios.name ?? device.ios.udid,
-			workspace: env.path,
-			...slot,
-			id: device.ios.udid,
-			owned: device.ios.owned
-		});
-		if (device.android?.name && !device.android.physical) emulators.set(device.android.name, {
-			kind: "emulator",
-			name: device.android.name,
-			workspace: env.path,
-			...slot,
-			id: device.android.name,
-			owned: device.android.owned
-		});
-	}
-	for (const p of processes) {
-		const shared = SHARED.find(({ pattern }) => pattern.test(p.command));
-		if (shared) {
-			const owner = {
-				kind: "shared",
-				name: shared.name,
-				workspace: null,
-				id: null,
-				owned: false
-			};
-			claim(p.pid, `shared:${shared.name}`, owner, fallbackOf);
-			continue;
-		}
-		if (STIM_SERVER_COMMAND.test(p.command)) {
-			claim(p.pid, "server", {
-				kind: "server",
-				name: "stim-server",
-				workspace: null,
-				id: null,
-				owned: false
-			}, fallbackOf);
-			continue;
-		}
-		const udid = LAUNCHD_SIM.exec(p.command)?.[1]?.toUpperCase();
-		if (udid) {
-			const owner = sims.get(udid) ?? {
-				kind: "simulator",
-				name: simNames[udid] ?? udid,
-				workspace: null,
-				id: udid,
-				owned: false
-			};
-			claim(p.pid, `simulator:${udid}`, owner);
-			continue;
-		}
-		const avd = emulatorAvd(p.command);
-		if (avd) {
-			const owner = emulators.get(avd) ?? {
-				kind: "emulator",
-				name: avd,
-				workspace: null,
-				id: avd,
-				owned: false
-			};
-			claim(p.pid, `emulator:${avd}`, owner);
-		}
-	}
-	const present = new Set(processes.map((p) => p.pid));
-	const byPath = new Map(environments.map((env) => [env.path, env]));
-	for (const root of roots) {
-		const env = byPath.get(root.path);
-		if (!env) continue;
-		const metroPids = [root.supervisorPid, env.metro?.running ? env.metro.pid : null];
-		for (const pid of metroPids) if (pid && present.has(pid)) {
-			const port = env.metro?.port ?? null;
-			claim(pid, `metro:${env.path}`, workspaceOwner("metro", env, port ? `Metro :${port}` : "Metro", port ? String(port) : null));
-		}
-		if (root.build && present.has(root.build.pid)) {
-			const label = {
-				ios: "iOS build",
-				android: "Android build",
-				macos: "macOS build"
-			}[root.build.platform];
-			claim(root.build.pid, `build:${env.path}`, workspaceOwner("build", env, label, root.build.platform));
-		}
-		for (const pid of root.macosPids ?? []) if (present.has(pid)) claim(pid, `macos:${env.path}`, workspaceOwner("macos", env, env.macos?.product ?? "macOS app", null));
-		for (const pid of root.browserPids) if (present.has(pid)) claim(pid, `browser:${env.path}`, workspaceOwner("browser", env, "Chrome", null));
-	}
-	const parentOf = new Map(processes.map((p) => [p.pid, p.ppid]));
-	const totals = /* @__PURE__ */ new Map();
-	for (const p of processes) {
-		let pid = p.pid;
-		let key;
-		let fallback;
-		for (let depth = 0; pid !== void 0 && pid > 1 && depth < MAX_DEPTH; depth++) {
-			key = rootOf.get(pid);
-			if (key) break;
-			fallback ??= fallbackOf.get(pid);
-			pid = parentOf.get(pid);
-		}
-		key ??= fallback;
-		if (!key) continue;
-		const total = totals.get(key) ?? {
-			rssKb: 0,
-			memoryKb: 0,
-			cpu: 0,
-			processes: 0
-		};
-		total.rssKb += p.rssKb;
-		const footprint = footprints?.get(p.pid);
-		total.memoryKb += footprint === void 0 ? p.rssKb : footprint / 1024;
-		total.cpu += p.cpuPercent;
-		total.processes += 1;
-		totals.set(key, total);
-	}
-	const list = [];
-	for (const [key, owner] of owners) {
-		const total = totals.get(key);
-		if (total) list.push({
-			...owner,
-			cpuPercent: Math.round(total.cpu),
-			residentMb: Math.round(total.rssKb / 1024),
-			memoryMb: Math.round(total.memoryKb / 1024),
-			processes: total.processes
-		});
-	}
-	list.sort((x, y) => rank(x) - rank(y) || (x.workspace ?? "~").localeCompare(y.workspace ?? "~") || x.name.localeCompare(y.name));
-	return {
-		memorySource: footprints ? "footprint" : "rss",
-		owners: list
-	};
-}
-//#endregion
-//#region src/commands/gc/progress.ts
-function phase(label, text) {
-	console.error(chalk.dim(phaseLine(label, text)));
-}
-//#endregion
-//#region src/commands/gc/memory.ts
-const WATCHMAN_KIND = "watchman";
-const GRADLE_DAEMONS_KIND = "gradle-daemons";
-/** The memory kind `--cache` names, or null for any other name. */
-function memoryCacheKind(cache) {
-	const wanted = cache?.trim().toLowerCase();
-	return wanted === "watchman" || wanted === "gradle-daemons" ? wanted : null;
-}
-/** Which helpers a gc run inspects: both without --cache, one for its own kind, none for any other --cache. */
-function memoryScope(cache) {
-	if (!cache?.trim()) return {
-		watchman: true,
-		gradle: true
-	};
-	const kind = memoryCacheKind(cache);
-	return kind ? {
-		watchman: kind === WATCHMAN_KIND,
-		gradle: kind === GRADLE_DAEMONS_KIND
-	} : null;
-}
-const WATCHMAN_TIMEOUT_MS = 5e3;
-const WATCHMAN_DOCTOR_BYTES = 2 * 1024 ** 3;
-const GRADLE_STATUS_TIMEOUT_MS = 2e4;
-const GRADLE_STOP_TIMEOUT_MS = 6e4;
-const LSOF_TIMEOUT_MS = 1e4;
-const ROOT_PROBES_AT_ONCE = 4;
-const GRADLE_DAEMON_CLASS = /\borg\.gradle\.launcher\.daemon\.bootstrap\.GradleDaemon\s+(\S+)/;
-const KOTLIN_DAEMON_CLASS = /^\S.*?\/bin\/java\s.*\sorg\.jetbrains\.kotlin\.daemon\.KotlinCompileDaemon(\s|$)/;
-/**
-* The Gradle version, Java home and distribution of a `GradleDaemon` process from its command line. The
-* distribution is the directory whose `lib/` holds the daemon's main jar (`gradle-daemon-main-<v>.jar`, or
-* `gradle-launcher-<v>.jar` before Gradle 8.13), so `<distribution>/bin/gradle` is the daemon's own launcher.
-*/
-function parseGradleDaemonCommand(command) {
-	const version = GRADLE_DAEMON_CLASS.exec(command)?.[1];
-	const java = /^(\/.*?)\/bin\/java\s/.exec(command)?.[1];
-	if (!version || !java) return null;
-	const jar = /(?:^|\s)-(?:cp|classpath)\s+(?:[^\s]*:)?(\/.*?\/lib\/gradle-(?:daemon-main|launcher)-[^/\s:]+\.jar)(?=[\s:])/.exec(command)?.[1];
-	return {
-		version,
-		javaHome: java,
-		distribution: jar ? dirname(dirname(jar)) : null
-	};
-}
-function isKotlinDaemonCommand(command) {
-	return KOTLIN_DAEMON_CLASS.test(command) && !GRADLE_DAEMON_CLASS.test(command);
-}
-/**
-* The offload client whose Gradle home under `workerRoot` a daemon uses: named by its classpath, as stim-server
-* matches it, or by the Gradle home it runs in.
-*/
-function offloadClientOf(command, workerRoot, gradleHome) {
-	const root = resolve(workerRoot).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	const home = new RegExp(`${root}/([^/\\s]+)/cache/gradle(/|$)`);
-	return home.exec(command)?.[1] ?? (gradleHome ? home.exec(gradleHome)?.[1] ?? null : null);
-}
-/** `gradle --status` rows: the state of each daemon pid it lists, lowercased (idle, busy, stopped, ...). */
-function parseGradleStatus(output) {
-	const states = /* @__PURE__ */ new Map();
-	for (const line of output.split("\n")) {
-		const match = /^\s*(\d+)\s+([A-Z][A-Z_]*)\s+\S/.exec(line);
-		if (match) states.set(Number(match[1]), match[2].toLowerCase());
-	}
-	return states;
-}
-/** `lsof -F pnT` output: each pid's open file names and its ESTABLISHED TCP connections. */
-function parseLsof(output) {
-	const processes = /* @__PURE__ */ new Map();
-	let current = null;
-	let name = null;
-	for (const line of output.split("\n")) if (line.startsWith("p")) {
-		const pid = Number(line.slice(1));
-		current = processes.get(pid) ?? {
-			files: [],
-			connections: []
-		};
-		processes.set(pid, current);
-	} else if (current && line.startsWith("n")) {
-		name = line.slice(1);
-		current.files.push(name);
-	} else if (current && name?.includes("->") && line === "TST=ESTABLISHED") current.connections.push(name);
-	return processes;
-}
-/**
-* The process at the other end of each of `pid`'s connections, found among the other processes lsof listed by the
-* reversed `remote->local` name; null for a peer lsof did not list.
-*/
-function connectionPeers(pid, lsof) {
-	return (lsof.get(pid)?.connections ?? []).map((connection) => {
-		const [local, remote] = connection.split("->");
-		const reversed = `${remote}->${local}`;
-		for (const [other, entry] of lsof) if (other !== pid && entry.connections.includes(reversed)) return other;
-		return null;
-	});
-}
-/** The Gradle user home a daemon runs in: the one whose `daemon/<version>/daemon-<pid>.out.log` it holds open. */
-function gradleHomeFromFiles(pid, version, files) {
-	const suffix = `/daemon/${version}/daemon-${pid}.out.log`;
-	const log = files.find((file) => file.endsWith(suffix));
-	return log ? log.slice(0, -suffix.length) : null;
-}
-const fsProbe = {
-	exists: existsSync,
-	isFile(path) {
-		try {
-			return statSync(path).isFile();
-		} catch {
-			return false;
-		}
-	},
-	read(path) {
-		try {
-			return readFileSync(path, "utf8");
-		} catch {
-			return null;
-		}
-	},
-	mounted: (path) => isOnMountedVolume(path)
-};
-/**
-* Why a watch root is stale: its directory is gone from a mounted volume, or the nearest `.git` above it is a
-* linked worktree's `.git` file whose gitdir no longer exists (git pruned the worktree and left the directory).
-* Null when it is live or when that cannot be proven, such as a path on a volume that is not mounted.
-*/
-function watchmanRootStaleness(path, probe = fsProbe) {
-	if (!probe.exists(path)) return probe.mounted(path) ? "missing" : null;
-	for (let dir = path;; dir = dirname(dir)) {
-		const git = join(dir, ".git");
-		if (probe.exists(git)) {
-			if (!probe.isFile(git)) return null;
-			const target = /^gitdir:\s*(.+?)\s*$/m.exec(probe.read(git) ?? "")?.[1];
-			if (!target) return null;
-			const gitdir = isAbsolute(target) ? target : resolve(dir, target);
-			return probe.exists(gitdir) || !probe.mounted(gitdir) ? null : "pruned-worktree";
-		}
-		if (dirname(dir) === dir) return null;
-	}
-}
-function staleText(stale) {
-	return stale === "missing" ? "its directory is gone" : "its linked worktree was pruned";
-}
-function planWatchmanRoot(root) {
-	const subscriptions = root.subscribers?.length ?? null;
-	const base = {
-		path: root.path,
-		stale: root.stale,
-		subscriptions,
-		triggers: root.triggers
-	};
-	if (root.stale === null) return {
-		...base,
-		removable: false,
-		detail: null
-	};
-	const kept = subscriptions === null ? "could not list its subscriptions" : subscriptions > 0 ? `${subscriptions} subscription(s) still use it` : root.triggers === null ? "could not list its triggers" : root.triggers > 0 ? `it has ${root.triggers} trigger(s)` : null;
-	return {
-		...base,
-		removable: kept === null,
-		detail: kept ? `${staleText(root.stale)}, but ${kept}` : staleText(root.stale)
-	};
-}
-/**
-* Decides the watchman roots gc removes and whether it may shut the daemon down. A stale root goes only while no
-* subscription or trigger uses it. The daemon goes only when `debug-status` lists no client besides gc's own call and
-* every root's subscriptions and triggers could be read, no kept root has a trigger, and no root has a subscription;
-* `describeClient` names each client that keeps it.
-*/
-function planWatchman(facts, describeClient) {
-	const roots = (facts.roots ?? []).map(planWatchmanRoot);
-	const unreadRoots = facts.roots === null || roots.some((root) => root.subscriptions === null || root.triggers === null);
-	const triggered = roots.filter((root) => !root.removable && (root.triggers ?? 0) > 0);
-	let reason = null;
-	let detail = null;
-	if (facts.clients === null || unreadRoots) {
-		reason = "unknown";
-		detail = facts.clients === null ? "watchman debug-status did not list its clients" : "could not list the subscriptions and triggers of every root";
-	} else if (facts.clients.length > 0) {
-		reason = "in-use";
-		detail = `used by ${[...new Set(facts.clients.map(describeClient))].join(", ")}; shutting it down would break their file watching`;
-	} else if (roots.some((root) => !root.removable && (root.subscriptions ?? 0) > 0)) {
-		reason = "in-use";
-		detail = "a root still has a subscription";
-	} else if (triggered.length > 0) {
-		reason = "in-use";
-		detail = `${triggered.map((root) => root.path).join(", ")} ha${triggered.length === 1 ? "s" : "ve"} triggers that stop firing while watchman is down`;
-	}
-	return {
-		process: {
-			kind: "watchman",
-			cacheKind: WATCHMAN_KIND,
-			pid: facts.pid,
-			startedAt: facts.startedAt,
-			bytes: facts.bytes,
-			measure: facts.measure,
-			version: null,
-			gradleHome: null,
-			offloadClient: null,
-			state: reason === "in-use" ? "busy" : reason === "unknown" ? "unknown" : "idle",
-			reclaimable: reason === null,
-			reason,
-			detail
-		},
-		roots
-	};
-}
-/**
-* Decides which Gradle and Kotlin daemons gc may stop. A running Stim build (`buildRunning`) keeps every one. An
-* offload worker's daemon is left to stim-server while it runs. A Gradle daemon goes only when its own `gradle
-* --status` says IDLE. A Kotlin daemon goes only when every Gradle daemon is idle and each of its connections comes from
-* a Gradle daemon gc stops in the same run.
-*/
-function planDaemons({ gradle, kotlin, buildRunning, stimServerRunning }) {
-	const plans = [];
-	const gradleBusy = gradle.some((daemon) => !("state" in daemon.status) || daemon.status.state !== "idle");
-	for (const daemon of gradle) {
-		const state = "state" in daemon.status ? daemon.status.state : null;
-		const idle = state === "idle";
-		let reason = null;
-		let detail = null;
-		if (daemon.offloadClient !== null && stimServerRunning) {
-			reason = "stim-server";
-			detail = `stim-server stops the daemons of offload client ${daemon.offloadClient} when that client loses build or memory runs low`;
-		} else if (buildRunning) {
-			reason = "build-running";
-			detail = buildRunning;
-		} else if (state === "busy") {
-			reason = "busy";
-			detail = "a build is using it";
-		} else if (!idle) {
-			reason = "unknown";
-			detail = "unknown" in daemon.status ? daemon.status.unknown : `gradle --status reports it ${state}`;
-		}
-		plans.push({
-			kind: "gradleDaemon",
-			cacheKind: GRADLE_DAEMONS_KIND,
-			pid: daemon.pid,
-			startedAt: daemon.startedAt,
-			bytes: daemon.bytes,
-			measure: daemon.measure,
-			version: daemon.command.version,
-			gradleHome: daemon.gradleHome,
-			offloadClient: daemon.offloadClient,
-			state: idle ? "idle" : state === "busy" ? "busy" : "unknown",
-			reclaimable: reason === null,
-			reason,
-			detail
-		});
-	}
-	const stopping = new Set(plans.filter((plan) => plan.reclaimable).map((plan) => plan.pid));
-	for (const daemon of kotlin) {
-		const clients = daemon.peers?.filter((peer) => peer === null || !stopping.has(peer)) ?? [];
-		let reason = null;
-		let detail = null;
-		if (buildRunning) {
-			reason = "build-running";
-			detail = buildRunning;
-		} else if (daemon.peers === null) {
-			reason = "unknown";
-			detail = "lsof could not list its connections";
-		} else if (gradleBusy) {
-			reason = "busy";
-			detail = "a Gradle daemon is busy or its state is unknown, and it may be compiling through this one";
-		} else if (clients.length > 0) {
-			reason = "busy";
-			detail = `${clients.length} connection(s) from a process gc does not stop are open`;
-		}
-		plans.push({
-			kind: "kotlinDaemon",
-			cacheKind: GRADLE_DAEMONS_KIND,
-			pid: daemon.pid,
-			startedAt: daemon.startedAt,
-			bytes: daemon.bytes,
-			measure: daemon.measure,
-			version: null,
-			gradleHome: null,
-			offloadClient: null,
-			state: reason === null ? "idle" : reason === "unknown" ? "unknown" : "busy",
-			reclaimable: reason === null,
-			reason,
-			detail
-		});
-	}
-	return plans;
-}
-/**
-* Why no Gradle or Kotlin daemon may be stopped now, or null. An Android build lock, or a build slot that no live iOS
-* build lock of the same process holds, counts as a running build; one whose holder is unresolved counts too.
-*/
-function runningBuild(locks, slots) {
-	const android = locks.find((lock) => lock.platform === "android" && (lock.alive || lock.unresolved));
-	if (android) return `${android.unresolved ? "an unresolved" : "a running"} Android build holds ${android.path} (pid ${android.pid ?? "?"}, ${android.projectRoot || "unrecorded workspace"})`;
-	const ios = new Set(locks.filter((lock) => lock.platform === "ios" && lock.alive).map((lock) => lock.pid));
-	const slot = slots.find((s) => (s.alive || s.unresolved) && !(s.alive && s.pid !== null && ios.has(s.pid)));
-	if (slot) return `${slot.unresolved ? "an unresolved" : "a running"} build holds build slot ${slot.index ?? "?"} (pid ${slot.pid ?? "?"}, ${slot.projectRoot || "unrecorded workspace"})`;
-	return null;
-}
-/** A watchman client's pid resolved to the Stim workspace whose supervisor it is or descends from. */
-function stimWorkspaceOf(pid, parentOf, supervisors) {
-	let current = pid;
-	for (let depth = 0; current !== void 0 && current > 1 && depth < 64; depth++) {
-		const workspace = supervisors.get(current);
-		if (workspace) return workspace;
-		current = parentOf.get(current);
-	}
-	return null;
-}
-function reclaimableBytes(report, kind) {
-	return report.processes.filter((entry) => entry.reclaimable && (kind === void 0 || entry.cacheKind === kind)).reduce((sum, entry) => sum + entry.bytes, 0);
-}
-const boundWatchman = async (args) => {
-	const answer = JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs: WATCHMAN_TIMEOUT_MS }));
-	const error = answer?.error;
-	if (error !== void 0) throw new Error(String(error));
-	return answer;
-};
-async function quietly(fn) {
-	try {
-		return await fn();
-	} catch {
-		return null;
-	}
-}
-/**
-* `watchman debug-status` with gc's own call left out of its clients. The call is spawned directly so its pid is
-* known: debug-status lists the asking CLI as a client too.
-*/
-function watchmanClients() {
-	return new Promise((done) => {
-		let child;
-		try {
-			child = getExecutor().spawn("watchman", ["--no-spawn", "debug-status"], { stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			] });
-		} catch {
-			done(null);
-			return;
-		}
-		const self = child.pid;
-		const chunks = [];
-		const timer = setTimeout(() => child.kill("SIGTERM"), WATCHMAN_TIMEOUT_MS);
-		child.stdout?.on("data", (chunk) => chunks.push(chunk));
-		child.on("error", () => {
-			clearTimeout(timer);
-			done(null);
-		});
-		child.on("close", (status) => {
-			clearTimeout(timer);
-			let clients = null;
-			try {
-				if (status === 0 && self !== void 0) clients = parseWatchmanClients(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-			} catch {}
-			done(clients ? clients.filter((client) => client.pid !== self) : null);
-		});
-	});
-}
-async function collectWatchmanRoots(pid, progress) {
-	const watchman = boundWatchman;
-	const paths = parseWatchRoots(await quietly(() => watchman(["watch-list"])));
-	if (!paths) return null;
-	if (progress) phase("daemons", `watchman pid ${pid}: checking ${plural(paths.length, "root")}`);
-	const roots = [];
-	let next = 0;
-	const probe = async () => {
-		while (next < paths.length) {
-			const index = next++;
-			const path = paths[index];
-			const [subscriptions, triggers] = await Promise.all([quietly(() => watchman(["debug-get-subscriptions", path])), quietly(() => watchman(["trigger-list", path]))]);
-			roots[index] = {
-				path,
-				stale: watchmanRootStaleness(path),
-				subscribers: parseSubscriberNames(subscriptions),
-				triggers: parseTriggerCount(triggers)
-			};
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(ROOT_PROBES_AT_ONCE, paths.length) }, probe));
-	return roots;
-}
-function measureOf(pid, rows, footprints) {
-	const footprint = footprints?.get(pid);
-	if (footprint !== void 0) return {
-		bytes: footprint,
-		measure: "footprint"
-	};
-	return {
-		bytes: (rows.get(pid)?.rssKb ?? 0) * 1024,
-		measure: "rss"
-	};
-}
-function supervisorPids() {
-	const supervisors = /* @__PURE__ */ new Map();
-	for (const root of Object.keys(loadConfig()?.projects ?? {})) {
-		const pid = readPidFile(root);
-		if (pid) supervisors.set(pid, root);
-	}
-	return supervisors;
-}
-async function readLsof(pids) {
-	if (pids.length === 0) return /* @__PURE__ */ new Map();
-	try {
-		return parseLsof(await getExecutor().runFileAsync("lsof", [
-			"-n",
-			"-P",
-			"-F",
-			"pnT",
-			"-p",
-			pids.join(",")
-		], { timeoutMs: LSOF_TIMEOUT_MS }));
-	} catch (error) {
-		const { status, signal: killed, stdout } = error;
-		return status === 1 && !killed && typeof stdout === "string" && stdout ? parseLsof(stdout) : null;
-	}
-}
-async function gradleStatus(command, home) {
-	if (!command.distribution) return { unknown: "could not find its Gradle distribution on its classpath" };
-	const launcher = join(command.distribution, "bin", "gradle");
-	if (!existsSync(launcher)) return { unknown: `its distribution has no ${launcher}` };
-	try {
-		return parseGradleStatus(await getExecutor().runFileAsync(launcher, [
-			"--status",
-			"-q",
-			"-g",
-			home
-		], {
-			cwd: home,
-			env: { JAVA_HOME: command.javaHome },
-			omitEnv: ["GRADLE_OPTS", "JAVA_OPTS"],
-			timeoutMs: GRADLE_STATUS_TIMEOUT_MS
-		}));
-	} catch (error) {
-		return { unknown: `gradle --status failed: ${error.message.split("\n")[0]}` };
-	}
-}
-function groupKey(command, home) {
-	return JSON.stringify([
-		home,
-		command.version,
-		command.distribution,
-		command.javaHome
-	]);
-}
-async function collectGradleFacts(rows, byPid, footprints, stimServerRunning, progress) {
-	const gradleRows = rows.flatMap((row) => {
-		const command = parseGradleDaemonCommand(row.command);
-		return command ? [{
-			row,
-			command
-		}] : [];
-	});
-	const kotlinRows = rows.filter((row) => isKotlinDaemonCommand(row.command));
-	if (gradleRows.length === 0 && kotlinRows.length === 0) return {
-		gradle: [],
-		kotlin: []
-	};
-	if (progress) phase("daemons", `checking ${plural(gradleRows.length, "Gradle daemon")} and ${plural(kotlinRows.length, "Kotlin daemon")}`);
-	const lsof = await readLsof([...gradleRows.map(({ row }) => row.pid), ...kotlinRows.map((row) => row.pid)]);
-	const workerRoot = buildWorkerRoot();
-	const homes = gradleRows.map(({ row, command }) => {
-		const files = lsof?.get(row.pid)?.files;
-		return files ? gradleHomeFromFiles(row.pid, command.version, files) : null;
-	});
-	const offload = gradleRows.map(({ row }, index) => offloadClientOf(row.command, workerRoot, homes[index] ?? null));
-	const statuses = /* @__PURE__ */ new Map();
-	gradleRows.forEach(({ command }, index) => {
-		const home = homes[index];
-		if (offload[index] !== null && stimServerRunning) return;
-		if (home && !statuses.has(groupKey(command, home))) {
-			if (progress) phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`);
-			statuses.set(groupKey(command, home), gradleStatus(command, home));
-		}
-	});
-	const gradle = [];
-	for (const [index, { row, command }] of gradleRows.entries()) {
-		const home = homes[index] ?? null;
-		let status;
-		if (offload[index] !== null && stimServerRunning) status = { unknown: "stim-server manages it" };
-		else if (!home) status = { unknown: lsof ? "could not find its Gradle user home among its open files" : "lsof failed" };
-		else {
-			const states = await statuses.get(groupKey(command, home));
-			if (states instanceof Map) {
-				const state = states.get(row.pid);
-				status = state ? { state } : { unknown: "gradle --status did not list it" };
-			} else status = states;
-		}
-		gradle.push({
-			pid: row.pid,
-			startedAt: row.startedAt,
-			...measureOf(row.pid, byPid, footprints),
-			command,
-			gradleHome: home,
-			offloadClient: offload[index] ?? null,
-			status
-		});
-	}
-	return {
-		gradle,
-		kotlin: kotlinRows.map((row) => Object.assign(measureOf(row.pid, byPid, footprints), {
-			pid: row.pid,
-			startedAt: row.startedAt,
-			peers: lsof?.get(row.pid) ? connectionPeers(row.pid, lsof) : null
-		}))
-	};
-}
-async function collectWatchmanFacts(byPid, footprints, progress) {
-	const pid = parseWatchmanPid(await quietly(() => boundWatchman(["get-pid"])));
-	if (pid === null) return null;
-	const roots = await collectWatchmanRoots(pid, progress);
-	const clients = (await watchmanClients())?.filter((client) => client.pid !== pid) ?? null;
-	return {
-		pid,
-		startedAt: byPid.get(pid)?.startedAt ?? null,
-		...measureOf(pid, byPid, footprints),
-		roots,
-		clients
-	};
-}
-function watchmanClientDescriber(rows) {
-	const parentOf = new Map(rows.map((row) => [row.pid, row.ppid]));
-	const supervisors = supervisorPids();
-	return (client) => {
-		const workspace = stimWorkspaceOf(client.pid, parentOf, supervisors);
-		return workspace ? `the Stim workspace ${workspace}` : `${client.name ?? "a client"} (pid ${client.pid})`;
-	};
-}
-function memorySweepIsScoped() {
-	return Boolean(process.env.STIM_HOME);
-}
-/** The report of a run whose STIM_HOME is set: the helpers are machine-global, so none is inspected or stopped. */
-function scopedMemoryReport() {
-	return {
-		processes: [],
-		watchmanRoots: [],
-		notices: ["memory sweep skipped: STIM_HOME scopes this config, but watchman and the Gradle and Kotlin daemons are machine-global"]
-	};
-}
-async function collectMemoryReport(scope, progress = false) {
-	const report = {
-		processes: [],
-		watchmanRoots: [],
-		notices: []
-	};
-	if (process.platform === "win32") return report;
-	const rows = createDeviceProcessTables().host();
-	if (rows === null) {
-		report.notices.push("memory sweep skipped: ps did not answer");
-		return report;
-	}
-	const byPid = new Map(rows.map((row) => [row.pid, row]));
-	const footprints = await readFootprints();
-	if (scope.watchman) {
-		const facts = await collectWatchmanFacts(byPid, footprints, progress);
-		if (facts) {
-			const plan = planWatchman(facts, watchmanClientDescriber(rows));
-			report.processes.push(plan.process);
-			report.watchmanRoots = plan.roots;
-		} else if (!scope.gradle) report.notices.push("no watchman daemon answered");
-	}
-	if (scope.gradle) {
-		const stimServerRunning = rows.some((row) => STIM_SERVER_COMMAND.test(row.command));
-		const facts = await collectGradleFacts(rows, byPid, footprints, stimServerRunning, progress);
-		report.processes.push(...planDaemons({
-			...facts,
-			buildRunning: facts.gradle.length || facts.kotlin.length ? runningBuild(listBuildLocks(), listBuildSlots()) : null,
-			stimServerRunning
-		}));
-		if (!scope.watchman && report.processes.length === 0) report.notices.push("no Gradle or Kotlin daemon is running");
-	}
-	return report;
-}
-function processLabel(entry) {
-	if (entry.kind === "watchman") return `watchman pid ${entry.pid}`;
-	if (entry.kind === "kotlinDaemon") return `Kotlin compile daemon pid ${entry.pid}`;
-	const where = entry.offloadClient ? `offload client ${entry.offloadClient}` : entry.gradleHome ?? "unknown Gradle home";
-	return `Gradle ${entry.version ?? "?"} daemon pid ${entry.pid} (${where})`;
-}
-function uptime(startedAt, now) {
-	const at = startedAt ? Date.parse(startedAt) : NaN;
-	return Number.isFinite(at) ? `up ${formatLongDuration(Math.max(0, now - at))}` : "uptime unknown";
-}
-function memoryLines(report, scoped, now = Date.now()) {
-	if (!report || report.processes.length === 0 && report.notices.length === 0) return [];
-	const lines = [`Memory (${report.processes.some((entry) => entry.measure === "rss") ? "footprint, resident size where unreadable" : "physical footprint"}) - shared helpers that grow while they run; only --cache watchman or gradle-daemons stops them:`];
-	for (const entry of report.processes) {
-		const state = entry.reclaimable ? "idle" : entry.kind === "watchman" && entry.state === "busy" ? "in use" : entry.state;
-		lines.push(`  ${processLabel(entry)} ${formatBytes(entry.bytes)}, ${uptime(entry.startedAt, now)}, ${state}`);
-		if (entry.kind === "watchman") {
-			const stale = report.watchmanRoots.filter((root) => root.stale !== null).length;
-			lines.push(`              ${report.watchmanRoots.length} root(s), ${stale} stale`);
-			for (const root of report.watchmanRoots.filter((r) => r.stale !== null)) lines.push(`              stale root ${root.path}: ${root.detail}${root.removable ? "" : "; kept"}`);
-		}
-		if (entry.detail) lines.push(`              ${entry.reclaimable ? "" : "kept: "}${entry.detail}`);
-	}
-	for (const notice of report.notices) lines.push(`  ${notice}`);
-	const kinds = scoped ? [scoped] : [WATCHMAN_KIND, GRADLE_DAEMONS_KIND];
-	const parts = [];
-	for (const kind of kinds) {
-		if (!report.processes.some((entry) => entry.cacheKind === kind)) continue;
-		const roots = kind === "watchman" ? report.watchmanRoots.filter((root) => root.removable).length : 0;
-		const note = roots ? ` (and ${roots} stale root(s) removed)` : "";
-		parts.push(`${formatBytes(reclaimableBytes(report, kind))} with stim gc --delete --cache ${kind}${note}`);
-	}
-	if (parts.length) lines.push(`  reclaimable ${formatBytes(reclaimableBytes(report))}: ${parts.join("; ")}`);
-	return lines;
-}
-function sameProcess(entry, rows) {
-	const row = rows?.get(entry.pid);
-	return Boolean(row && entry.startedAt !== null && row.startedAt === entry.startedAt);
-}
-function signal(pid) {
-	try {
-		process.kill(pid, "SIGTERM");
-		return null;
-	} catch (error) {
-		return error.code === "ESRCH" ? null : error.message;
-	}
-}
-function keep(entry, kind, detail) {
-	console.log(chalk.yellow(`Kept ${processLabel(entry)}: ${detail}`));
-	recordGcResult(kind, "kept", processLabel(entry), {
-		id: String(entry.pid),
-		bytes: entry.bytes,
-		detail
-	});
-}
-async function reclaimWatchman(before) {
-	let failures = 0;
-	const fresh = await collectMemoryReport({
-		watchman: true,
-		gradle: false
-	}, true);
-	const daemon = fresh.processes.find((entry) => entry.kind === "watchman");
-	const planned = before.processes.find((entry) => entry.kind === "watchman");
-	if (!daemon || !planned || daemon.pid !== planned.pid) {
-		if (planned) keep(planned, "watchman", "the daemon changed or stopped since the report");
-		return 0;
-	}
-	for (const root of fresh.watchmanRoots.filter((r) => r.stale !== null)) {
-		if (!root.removable) {
-			console.log(chalk.yellow(`Kept the watchman root ${root.path}: ${root.detail}`));
-			recordGcResult("watchmanRoot", "kept", root.path, { detail: root.detail });
-			continue;
-		}
-		try {
-			phase("daemons", `removing stale watchman root ${root.path}`);
-			await boundWatchman(["watch-del", root.path]);
-			console.log(chalk.green(`Removed the stale watchman root ${root.path} (${root.detail})`));
-			recordGcResult("watchmanRoot", "done", root.path, { detail: root.detail });
-		} catch (error) {
-			failures++;
-			console.log(chalk.red(`Could not remove the watchman root ${root.path}: ${error.message}`));
-			recordGcResult("watchmanRoot", "failed", root.path, { detail: error.message });
-		}
-	}
-	const current = (await collectMemoryReport({
-		watchman: true,
-		gradle: false
-	}, true)).processes.find((entry) => entry.kind === "watchman");
-	if (!current || current.pid !== daemon.pid) return failures;
-	if (!current.reclaimable) {
-		keep(current, "watchman", current.detail ?? "it could not be proven unused");
-		return failures;
-	}
-	try {
-		phase("daemons", `shutting down watchman pid ${current.pid}: no client uses it`);
-		await boundWatchman(["shutdown-server"]);
-		console.log(chalk.green(`Shut down watchman pid ${current.pid}, freeing ${formatBytes(current.bytes)}; the next client that needs it starts it again`));
-		recordGcResult("watchman", "done", processLabel(current), {
-			id: String(current.pid),
-			bytes: current.bytes
-		});
-	} catch (error) {
-		failures++;
-		console.log(chalk.red(`Could not shut down watchman pid ${current.pid}: ${error.message}`));
-		recordGcResult("watchman", "failed", processLabel(current), {
-			id: String(current.pid),
-			bytes: current.bytes,
-			detail: error.message
-		});
-	}
-	return failures;
-}
-function stopKotlin(entry, rows) {
-	if (!sameProcess(entry, rows)) {
-		keep(entry, "kotlinDaemon", "the process changed or exited since the check");
-		return 0;
-	}
-	const error = signal(entry.pid);
-	if (error) {
-		console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
-		recordGcResult("kotlinDaemon", "failed", processLabel(entry), {
-			id: String(entry.pid),
-			bytes: entry.bytes,
-			detail: error
-		});
-		return 1;
-	}
-	console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
-	recordGcResult("kotlinDaemon", "done", processLabel(entry), {
-		id: String(entry.pid),
-		bytes: entry.bytes
-	});
-	return 0;
-}
-/**
-* Stops the Gradle daemons a fresh check still finds idle. When every daemon `gradle --status` lists for a home and
-* version is one of them, the daemon's own `gradle --stop` runs for that home; otherwise each idle one gets SIGTERM,
-* because `--stop` also stops the busy daemons of that home and version.
-*/
-async function stopGradle(idle, rows) {
-	let failures = 0;
-	const groups = /* @__PURE__ */ new Map();
-	for (const entry of idle) {
-		const command = parseGradleDaemonCommand(rows?.get(entry.pid)?.command ?? "");
-		if (!command || !entry.gradleHome || !sameProcess(entry, rows)) {
-			keep(entry, "gradleDaemon", "the process changed or exited since the check");
-			continue;
-		}
-		const key = groupKey(command, entry.gradleHome);
-		groups.set(key, [...groups.get(key) ?? [], entry]);
-	}
-	for (const [key, entries] of groups) {
-		const [home, , distribution, javaHome] = JSON.parse(key);
-		const command = parseGradleDaemonCommand(rows.get(entries[0].pid).command);
-		const building = runningBuild(listBuildLocks(), listBuildSlots());
-		if (building) {
-			for (const entry of entries) keep(entry, "gradleDaemon", building);
-			continue;
-		}
-		phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`);
-		let states = await gradleStatus(command, home);
-		let current = hostRows();
-		const listed = states instanceof Map ? [...states].filter(([, state]) => state !== "stopped") : [];
-		if (distribution !== null && listed.length > 0 && listed.every(([pid, state]) => state === "idle" && entries.some((entry) => entry.pid === pid))) try {
-			phase("daemons", `gradle --stop for Gradle ${command.version} in ${home}`);
-			await getExecutor().runFileAsync(join(distribution, "bin", "gradle"), [
-				"--stop",
-				"-q",
-				"-g",
-				home
-			], {
-				cwd: home,
-				env: { JAVA_HOME: javaHome },
-				omitEnv: ["GRADLE_OPTS", "JAVA_OPTS"],
-				timeoutMs: GRADLE_STOP_TIMEOUT_MS
-			});
-			for (const entry of entries) {
-				console.log(chalk.green(`Stopped ${processLabel(entry)} with gradle --stop, freeing ${formatBytes(entry.bytes)}`));
-				recordGcResult("gradleDaemon", "done", processLabel(entry), {
-					id: String(entry.pid),
-					bytes: entry.bytes
-				});
-			}
-			continue;
-		} catch (error) {
-			console.log(chalk.dim(`gradle --stop failed for ${home}; signalling each idle daemon: ${error.message.split("\n")[0]}`));
-			states = await gradleStatus(command, home);
-			current = hostRows();
-		}
-		for (const entry of entries) {
-			const state = states instanceof Map ? states.get(entry.pid) : void 0;
-			if (!sameProcess(entry, current)) {
-				keep(entry, "gradleDaemon", "the process changed or exited since the check");
-				continue;
-			}
-			if (state !== "idle") {
-				keep(entry, "gradleDaemon", state ? `gradle --status now reports it ${state}` : "gradle --status no longer lists it idle");
-				continue;
-			}
-			const error = signal(entry.pid);
-			if (error) {
-				failures++;
-				console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
-				recordGcResult("gradleDaemon", "failed", processLabel(entry), {
-					id: String(entry.pid),
-					bytes: entry.bytes,
-					detail: error
-				});
-				continue;
-			}
-			console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
-			recordGcResult("gradleDaemon", "done", processLabel(entry), {
-				id: String(entry.pid),
-				bytes: entry.bytes
-			});
-		}
-	}
-	return failures;
-}
-function stillPlanned(fresh, before, kind) {
-	const planned = new Map(before.processes.filter((entry) => entry.kind === kind).map((entry) => [entry.pid, entry]));
-	return fresh.processes.filter((entry) => entry.kind === kind && planned.get(entry.pid)?.startedAt === entry.startedAt);
-}
-function hostRows() {
-	const rows = createDeviceProcessTables().host();
-	return rows ? new Map(rows.map((row) => [row.pid, row])) : null;
-}
-const EXIT_WAIT_MS = 1e4;
-function alive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code !== "ESRCH";
-	}
-}
-async function waitForExit(pids) {
-	const running = pids.filter(alive);
-	if (running.length === 0) return;
-	phase("daemons", `waiting up to ${EXIT_WAIT_MS / 1e3}s for ${plural(running.length, "Gradle daemon")} to exit: pid ${running.join(", ")}`);
-	const deadline = Date.now() + EXIT_WAIT_MS;
-	while (running.some(alive) && Date.now() < deadline) await new Promise((done) => setTimeout(done, 200));
-}
-/** Stops the Gradle daemons first, then re-checks the Kotlin daemons, whose clients those Gradle daemons were. */
-async function reclaimDaemons(before) {
-	const scope = {
-		watchman: false,
-		gradle: true
-	};
-	const gradle = stillPlanned(await collectMemoryReport(scope, true), before, "gradleDaemon");
-	for (const entry of gradle.filter((e) => !e.reclaimable)) keep(entry, "gradleDaemon", entry.detail ?? "it could not be proven idle");
-	const stopping = gradle.filter((entry) => entry.reclaimable);
-	let failures = await stopGradle(stopping, hostRows());
-	if (!before.processes.some((entry) => entry.kind === "kotlinDaemon")) return failures;
-	await waitForExit(stopping.map((entry) => entry.pid));
-	const kotlin = stillPlanned(await collectMemoryReport(scope, true), before, "kotlinDaemon");
-	for (const entry of before.processes.filter((e) => e.kind === "kotlinDaemon" && e.reclaimable)) {
-		if (kotlin.some((current) => current.pid === entry.pid) || alive(entry.pid)) continue;
-		console.log(chalk.green(`${processLabel(entry)} exited with its Gradle daemon, freeing ${formatBytes(entry.bytes)}`));
-		recordGcResult("kotlinDaemon", "done", processLabel(entry), {
-			id: String(entry.pid),
-			bytes: entry.bytes
-		});
-	}
-	const rows = hostRows();
-	for (const entry of kotlin) if (entry.reclaimable) failures += stopKotlin(entry, rows);
-	else keep(entry, "kotlinDaemon", entry.detail ?? "it could not be proven idle");
-	return failures;
-}
-/** Whether `gc --delete --cache <cache>` would act on a memory kind: stop a process or remove a watchman root. */
-function memoryWorkPending(cache, report) {
-	if (!memoryCacheKind(cache) || !report) return false;
-	return reclaimableBytes(report) > 0 || report.watchmanRoots.some((root) => root.removable);
-}
-/** Acts on the one memory kind `--cache` names: never on an unscoped run or `--cache all`. */
-async function reclaimMemory(cache, report) {
-	const kind = memoryCacheKind(cache);
-	if (!kind || !report || report.processes.length === 0) return 0;
-	return kind === "watchman" ? reclaimWatchman(report) : reclaimDaemons(report);
-}
-/** A doctor note when watchman's footprint is over 2 GiB: only a restart shrinks it, and gc says when one is safe. */
-function watchmanFinding(report) {
-	const daemon = report.processes.find((entry) => entry.kind === "watchman");
-	if (!daemon || daemon.bytes < WATCHMAN_DOCTOR_BYTES) return null;
-	const stale = report.watchmanRoots.filter((root) => root.stale !== null).length;
-	const state = daemon.reclaimable ? "no client uses it now" : `it is kept: ${daemon.detail}`;
-	return {
-		level: "note",
-		title: `watchman uses ${formatBytes(daemon.bytes)}`,
-		detail: `The shared watchman daemon (pid ${daemon.pid}) has a ${formatBytes(daemon.bytes)} ${daemon.measure} with ${report.watchmanRoots.length} watched root(s), ${stale} of them stale; ${state}. Removing roots stops their recrawls, but only a restart returns the memory.`,
-		fix: "Run `stim gc --cache watchman` to see its roots and clients, then `stim gc --delete --cache watchman` once no workspace uses it."
-	};
-}
-async function inspectWatchmanMemory() {
-	if (process.platform === "win32" || memorySweepIsScoped()) return null;
-	return watchmanFinding(await collectMemoryReport({
-		watchman: true,
-		gradle: false
-	}));
-}
-//#endregion
-//#region src/commands/gc/archive-selector.ts
-const KIND_SELECTORS = {
-	"archived-logs": "logs",
-	"archived-recordings": "recordings",
-	"archived-agent": "agentActions"
-};
-function parseArchiveSelector(scope) {
-	const trimmed = scope.trim();
-	const colon = trimmed.indexOf(":");
-	const name = (colon === -1 ? trimmed : trimmed.slice(0, colon)).toLowerCase();
-	const id = colon === -1 ? null : trimmed.slice(colon + 1);
-	if (name === "archived") return {
-		kind: null,
-		id
-	};
-	const kind = KIND_SELECTORS[name];
-	return kind ? {
-		kind,
-		id
-	} : null;
-}
-//#endregion
-//#region src/commands/gc/caches.ts
-const DAY_MS$1 = 864e5;
-function cacheSweepIsScoped() {
-	return Boolean(process.env.STIM_HOME);
-}
-function isInsideConfigDir(dir) {
-	const root = canonicalPath(getConfigDir());
-	const target = canonicalPath(dir);
-	const rel = relative$1(root, target);
-	return rel !== "" && !rel.startsWith("..") && !isAbsolute$1(rel);
-}
-function machineGlobalReason(cache) {
-	if (!cacheSweepIsScoped()) return null;
-	if (cache.source === "registered") return null;
-	if (isInsideConfigDir(cache.dir)) return null;
-	return `STIM_HOME scopes this config, but ${cache.dir} is outside it and therefore machine-global`;
-}
-const EVERY_CACHE = "all";
-const WORKSPACE_OUTPUTS = "workspaces";
-const RECORDINGS = "recordings";
-const PARKED_DEVICES = "parked";
-function includesArchives(name) {
-	return name ? parseArchiveSelector(name) !== null : false;
-}
-function includesParkedDevices(name) {
-	return name?.trim().toLowerCase() === PARKED_DEVICES;
-}
-function includesRecordings(name) {
-	const wanted = name?.trim().toLowerCase();
-	return !wanted || wanted === EVERY_CACHE || wanted === RECORDINGS;
-}
-function isWorkspacesScope(name) {
-	return name?.trim().toLowerCase() === WORKSPACE_OUTPUTS;
-}
-function includesWorkspaceOutputs(name) {
-	const wanted = name?.trim().toLowerCase();
-	return !wanted || wanted === EVERY_CACHE || wanted === WORKSPACE_OUTPUTS;
-}
-/** Whether a --cache name selects something besides shared caches: recordings, parked devices or a memory kind. */
-function selectsBeyondCaches(name) {
-	return includesArchives(name) || includesRecordings(name) || includesParkedDevices(name) || memoryCacheKind(name) !== null;
-}
-function selectCaches(caches, name) {
-	if (!name) return caches;
-	const wanted = name.trim().toLowerCase();
-	if (wanted === EVERY_CACHE) return caches;
-	if (includesArchives(wanted) || wanted === WORKSPACE_OUTPUTS || wanted === RECORDINGS || wanted === PARKED_DEVICES || memoryCacheKind(wanted)) return [];
-	return caches.filter((c) => c.name.toLowerCase().includes(wanted) || c.dir.toLowerCase().includes(wanted));
-}
-function emptyVerdict(c) {
-	if (c.prune === "report-only") return {
-		willEmpty: false,
-		emptySkipped: "report-only shared cache; Stim never deletes it"
-	};
-	if (c.machineGlobal) return {
-		willEmpty: false,
-		emptySkipped: c.machineGlobal
-	};
-	if (!ownsItsDirectory(c)) return {
-		willEmpty: false,
-		emptySkipped: `${c.dir} is not a directory this cache owns`
-	};
-	return {
-		willEmpty: true,
-		emptySkipped: null
-	};
-}
-function planCacheEmptying(caches, all) {
-	const annotated = caches.map((c) => Object.assign({}, c, { machineGlobal: machineGlobalReason(c) }));
-	return all ? annotated.map((c) => Object.assign({}, c, emptyVerdict(c))) : annotated;
-}
-/** What `gc --delete --cache <name>` would do to each cache, for a report that does not run that scope. */
-function previewScopedEmptying(caches) {
-	return planCacheEmptying(caches, false).map((c) => Object.assign({}, c, { scopedEmpty: emptyVerdict(c) }));
-}
-function ownsItsDirectory(cache) {
-	return !Array.isArray(cache.files) && !cacheDirRefusal(cache.dir);
-}
-function emptyCache(cache) {
-	if (cache.prune === "report-only") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "report-only shared cache; Stim never deletes it"
-	};
-	if (cache.prune !== "atomic") return pruneCache(cache, {
-		olderThanDays: 0,
-		now: Date.now() + DAY_MS$1
-	});
-	let names;
-	try {
-		names = readdirSync$1(cache.dir);
-	} catch (e) {
-		return {
-			removed: 0,
-			bytes: 0,
-			skipped: `could not read ${cache.dir}: ${e.message}`
-		};
-	}
-	let removed = 0;
-	let failed = 0;
-	for (const name of names) try {
-		rmSync$1(join$1(cache.dir, name), {
-			recursive: true,
-			force: true
-		});
-		removed++;
-	} catch {
-		failed++;
-	}
-	return {
-		removed,
-		bytes: failed ? 0 : cache.bytes ?? 0,
-		failed,
-		skipped: null
-	};
-}
-function reportFailures(cache, failed) {
-	if (!failed) return;
-	const message = `${failed} entr${failed === 1 ? "y" : "ies"} in ${cache.dir} could not be removed`;
-	console.log(chalk.red(`${cache.name}: ${message}`));
-	recordGcResult("cache", "failed", cache.name, {
-		id: cache.dir,
-		detail: message
-	});
-	process.exitCode = 1;
-}
-function trimCaches(caches, olderThan) {
-	let cacheBytes = 0;
-	const trimmed = [];
-	for (const c of caches) {
-		if (c.machineGlobal) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${c.machineGlobal}`));
-			recordGcResult("cache", "kept", c.name, {
-				id: c.dir,
-				detail: c.machineGlobal
-			});
-			continue;
-		}
-		const r = pruneCache(c, { olderThanDays: olderThan });
-		if (r.skipped) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
-			recordGcResult("cache", "kept", c.name, {
-				id: c.dir,
-				detail: r.skipped
-			});
-		} else if (r.removed) {
-			cacheBytes += r.bytes;
-			trimmed.push(c);
-			recordGcResult("cache", "done", c.name, {
-				id: c.dir,
-				bytes: r.bytes
-			});
-			console.log(chalk.green(`Trimmed ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
-		} else if (!r.failed) console.log(chalk.dim(`${c.name}: nothing older than ${olderThan}d`));
-		reportFailures(c, r.failed);
-	}
-	if (cacheBytes) console.log(chalk.dim(`Trimmed ${formatBytes(cacheBytes)} of shared cache. The next build that wanted those entries pays to rebuild them.`));
-	return trimmed;
-}
-function emptyCaches(caches) {
-	let cacheBytes = 0;
-	for (const c of caches) {
-		if (!c.willEmpty) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${c.emptySkipped}`));
-			recordGcResult("cache", "kept", c.name, {
-				id: c.dir,
-				detail: c.emptySkipped ?? null
-			});
-			continue;
-		}
-		const r = emptyCache(c);
-		if (r.skipped) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
-			recordGcResult("cache", "kept", c.name, {
-				id: c.dir,
-				detail: r.skipped
-			});
-		} else if (r.removed) {
-			cacheBytes += r.bytes;
-			recordGcResult("cache", "done", c.name, {
-				id: c.dir,
-				bytes: r.bytes
-			});
-			console.log(chalk.green(`Emptied ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
-		} else if (!r.failed) console.log(chalk.dim(`${c.name}: already empty`));
-		reportFailures(c, r.failed);
-	}
-	if (cacheBytes) console.log(chalk.dim(`Emptied ${formatBytes(cacheBytes)} of shared cache. Every build that wanted any of it now pays to rebuild it.`));
-}
-//#endregion
-//#region src/commands/gc/devices.ts
-const DEVICE_LIST_TIMEOUT_MS$1 = 3e4;
-const AVD_SIZE_TIMEOUT_MS = 5e3;
-const DAY_MS = 864e5;
-function describeKept(ref) {
-	return ref.mounted ? `referenced by ${ref.path}` : `referenced by ${ref.path} (volume not mounted; kept just in case)`;
-}
-function findOrphanedDevices({ sims = [], avds = [], config, isMounted, deadProjects = [] }) {
-	const dead = new Set(deadProjects);
-	const referenced = /* @__PURE__ */ new Map();
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path)) continue;
-		const mounted = isMounted ? isMounted(path) : true;
-		for (const { platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			if (ios?.deviceUdid) referenced.set(ios.deviceUdid, {
-				path,
-				mounted
-			});
-			const android = platforms.android;
-			if (android?.avdName) referenced.set(android.avdName, {
-				path,
-				mounted
-			});
-		}
-	}
-	for (const sim of readParked("ios", { config })) referenced.set(sim.udid, {
-		path: "the simulator pool",
-		mounted: true
-	});
-	for (const avd of readParked("android", { config })) referenced.set(avd.name, {
-		path: "the emulator pool",
-		mounted: true
-	});
-	const orphaned = [];
-	const kept = [];
-	const unverified = [];
-	for (const sim of sims) {
-		if (!sim?.name?.startsWith("stim-")) continue;
-		const ref = referenced.get(sim.udid);
-		const device = {
-			kind: "ios",
-			id: sim.udid,
-			name: sim.name
-		};
-		if (!ref && !isStimCreated(device)) unverified.push(device);
-		else if (!ref) orphaned.push({
-			...device,
-			...simBytes(sim)
-		});
-		else kept.push({
-			kind: "ios",
-			id: sim.udid,
-			name: sim.name,
-			reason: describeKept(ref)
-		});
-	}
-	for (const avdName of avds) {
-		if (!avdName?.startsWith("stim-")) continue;
-		const ref = referenced.get(avdName);
-		const device = {
-			kind: "android",
-			id: avdName,
-			name: avdName
-		};
-		if (!ref && !isStimCreated(device)) unverified.push(device);
-		else if (!ref) orphaned.push(device);
-		else kept.push({
-			kind: "android",
-			id: avdName,
-			name: avdName,
-			reason: describeKept(ref)
-		});
-	}
-	return {
-		orphaned,
-		kept,
-		unverified
-	};
-}
-function simBytes(sim) {
-	return typeof sim.dataPathSize === "number" ? { bytes: sim.dataPathSize } : {};
-}
-function isStimCreated(device) {
-	return device.kind === "ios" ? isStimOwnedSim({
-		udid: device.id,
-		name: device.name
-	}) : isStimOwnedAvd(device.id);
-}
-function unverifiedDeviceCommand(device) {
-	if (device.kind === "ios") return `xcrun simctl delete ${device.id}`;
-	return device.directory ? `rm -rf ${JSON.stringify(device.directory)}` : `avdmanager delete avd -n ${JSON.stringify(device.id)}`;
-}
-function findStaleProjectDevices({ config, sims = [], avds = [], olderThanDays, now = Date.now(), lastTouched, deadProjects = [] }) {
-	if (!Number.isFinite(olderThanDays) || typeof lastTouched !== "function") return [];
-	const cutoff = now - olderThanDays * DAY_MS;
-	const dead = new Set(deadProjects);
-	const liveSims = new Map(sims.filter((s) => s?.name?.startsWith("stim-")).map((s) => [s.udid, s]));
-	const liveAvds = new Set(avds.filter((a) => typeof a === "string" && a.startsWith("stim-")));
-	const stale = [];
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path) || !isAbsolute$1(path)) continue;
-		const touched = lastTouched(path);
-		if (!Number.isFinite(touched) || touched >= cutoff) continue;
-		const idleDays = Math.floor((now - touched) / DAY_MS);
-		for (const { slot, platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			const sim = ios?.owned && ios.deviceUdid ? liveSims.get(ios.deviceUdid) : void 0;
-			if (sim) stale.push({
-				kind: "ios",
-				id: sim.udid,
-				name: sim.name,
-				project: path,
-				...slot === "default" ? {} : { slot },
-				idleDays,
-				...simBytes(sim)
-			});
-			const android = platforms.android;
-			if (android?.owned && android.avdName && liveAvds.has(android.avdName)) stale.push({
-				kind: "android",
-				id: android.avdName,
-				name: android.avdName,
-				project: path,
-				idleDays,
-				...slot === "default" ? {} : { slot }
-			});
-		}
-	}
-	return stale;
-}
-function findStaleDeviceRecords({ config, sims = [], avds = [], deadProjects = [], simsChecked = true, avdsChecked = true }) {
-	const dead = new Set(deadProjects);
-	const liveSims = new Set(sims.map((s) => s?.udid).filter(Boolean));
-	const liveAvds = new Set(avds.filter((a) => typeof a === "string"));
-	const stale = [];
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path)) continue;
-		for (const { slot, platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			if (simsChecked && ios?.deviceUdid && !liveSims.has(ios.deviceUdid)) stale.push({
-				kind: "ios",
-				id: ios.deviceUdid,
-				project: path,
-				...slot === "default" ? {} : { slot },
-				owned: Boolean(ios.owned)
-			});
-			const android = platforms.android;
-			if (avdsChecked && android?.avdName && !liveAvds.has(android.avdName)) stale.push({
-				kind: "android",
-				id: android.avdName,
-				project: path,
-				...slot === "default" ? {} : { slot },
-				owned: Boolean(android.owned)
-			});
-		}
-	}
-	return stale;
-}
-function describeUnverifiableDevices(simNames = [], avdNames = [], { reason = "no Stim config found" } = {}) {
-	const ours = [...simNames, ...avdNames].filter((n) => typeof n === "string" && n.startsWith("stim-"));
-	if (ours.length === 0) return [`${reason}; device sweep skipped`];
-	return [`${reason}, so ${ours.length} stim-created device(s) cannot be verified as orphaned: ${ours.join(", ")}`, "they were NOT touched. If they are stale, delete them with `xcrun simctl delete <udid>` or `avdmanager delete avd -n <name>`"];
-}
-function withAndroidAvdSizes(devices, { avdDirectory = ownedAvdDirectory, size = directorySize } = {}) {
-	return devices.map((device) => {
-		if (device.kind !== "android") return device;
-		const dir = device.orphanedDirectory?.directory ?? avdDirectory(device.id);
-		if (!dir) return device;
-		try {
-			const bytes = size(dir, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
-			return bytes > 0 ? {
-				...device,
-				bytes
-			} : device;
-		} catch {
-			return device;
-		}
-	});
-}
-function describeParkedSims(records, sims, deviceTypes, { simsChecked = true } = {}) {
-	const listed = new Map(sims.map((sim) => [sim.udid, sim]));
-	return records.map((record) => {
-		const sim = listed.get(record.udid);
-		return {
-			udid: record.udid,
-			name: sim?.name ?? record.name,
-			model: deviceTypes.find((d) => d.identifier === record.deviceTypeIdentifier)?.name ?? null,
-			runtime: sim ? parseRuntimeVersion(sim.runtime) : parseRuntimeVersion(record.runtimeIdentifier),
-			parkedAt: record.parkedAt,
-			app: record.bundleId ?? null,
-			bytes: typeof sim?.dataPathSize === "number" ? sim.dataPathSize : null,
-			listed: simsChecked ? Boolean(sim) : null
-		};
-	});
-}
-function parkedAtLeast(records, { olderThanDays = null, now = Date.now() }) {
-	if (olderThanDays === null) return [...records];
-	const cutoff = now - olderThanDays * DAY_MS;
-	return records.filter((record) => Date.parse(record.parkedAt) <= cutoff);
-}
-function collectParkedSims(deps, age = {}) {
-	const records = parkedAtLeast(readParked("ios"), age);
-	if (records.length === 0) return [];
-	let sims;
-	let deviceTypes = [];
-	try {
-		sims = (deps.listAllIosSims ?? listAllIosSims)({
-			timeoutMs: DEVICE_LIST_TIMEOUT_MS$1,
-			includeUnavailable: true
-		});
-	} catch {
-		return describeParkedSims(records, [], [], { simsChecked: false });
-	}
-	try {
-		deviceTypes = (deps.listIosDeviceTypes ?? listIosDeviceTypes)();
-	} catch {}
-	return describeParkedSims(records, sims, deviceTypes);
-}
-function poolConfigurationDeviceProfile(configuration) {
-	try {
-		const entries = JSON.parse(configuration);
-		const entry = Array.isArray(entries) ? entries.find((pair) => Array.isArray(pair) && pair[0] === "hw.device.name") : void 0;
-		return typeof entry?.[1] === "string" ? entry[1] : null;
-	} catch {
-		return null;
-	}
-}
-function collectParkedAvds(deps, age = {}) {
-	const records = parkedAtLeast(readParked("android"), age);
-	if (!records.length) return [];
-	let avds = null;
-	try {
-		avds = (deps.listAvds ?? listAvds)();
-	} catch {}
-	return records.map((record) => {
-		let bytes = null;
-		try {
-			const directory = (deps.avdDirectory ?? ownedAvdDirectory)(record.name);
-			if (directory) bytes = (deps.directorySize ?? directorySize)(directory, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
-		} catch {}
-		return {
-			name: record.name,
-			systemImage: record.systemImage,
-			deviceProfile: poolConfigurationDeviceProfile(record.configuration),
-			parkedAt: record.parkedAt,
-			app: record.packageName ?? null,
-			bytes,
-			listed: avds === null ? null : avds.includes(record.name)
-		};
-	});
-}
-function eraseParkedDevices(sims, avds) {
-	let failures = 0;
-	const devices = [...sims.map((sim) => ({
-		platform: "ios",
-		id: sim.udid,
-		name: sim.name,
-		listed: sim.listed,
-		bytes: sim.bytes
-	})), ...avds.map((avd) => ({
-		platform: "android",
-		id: avd.name,
-		name: avd.name,
-		listed: avd.listed,
-		bytes: avd.bytes
-	}))];
-	for (const device of devices) {
-		const what = `parked ${device.platform === "ios" ? "ios sim" : "android emulator"} ${device.name}`;
-		if (device.listed !== true) {
-			const unverified = device.listed === null;
-			const detail = unverified ? "Stim could not list devices to verify it; it was kept. Retry stim gc --cache parked --delete." : "it is not on this machine; stim gc --delete drops its pool record.";
-			if (unverified) failures++;
-			console.log((unverified ? chalk.red : chalk.dim)(`Did not erase ${what}: ${detail}`));
-			recordGcResult("parkedDevice", unverified ? "failed" : "kept", device.name, {
-				id: device.id,
-				detail
-			});
-			continue;
-		}
-		const result = device.platform === "ios" ? eraseParkedIosSim(device.id, { label: device.name }) : eraseParkedAvd(device.id);
-		if (result.status === "torn-down") {
-			console.log(chalk.green(`Erased ${what}; it stays parked`));
-			recordGcResult("parkedDevice", "done", device.name, {
-				id: device.id,
-				bytes: device.bytes
-			});
-		} else if (result.status === "failed") {
-			failures++;
-			console.log(chalk.red(`Failed to erase ${what}: ${result.reason}`));
-			recordGcResult("parkedDevice", "failed", device.name, {
-				id: device.id,
-				detail: result.reason
-			});
-		} else console.log(chalk.dim(`Skipped ${device.name}; it is no longer parked.`));
-	}
-	return failures;
-}
-function deleteParkedAvds(avds) {
-	let failures = 0;
-	for (const avd of avds) {
-		if (avd.listed === null) {
-			failures++;
-			console.log(chalk.red(`Could not verify parked android emulator ${avd.name}; its pool record was kept.`));
-			recordGcResult("parkedDevice", "failed", avd.name, {
-				id: avd.name,
-				detail: "Stim could not list emulators to verify it; its pool record was kept. Retry stim gc --delete."
-			});
-			continue;
-		}
-		const result = teardownParkedAvd(avd.name);
-		if (result.status === "failed") {
-			failures++;
-			console.log(chalk.red(`Failed to delete parked android emulator ${avd.name}: ${result.reason}`));
-			recordGcResult("parkedDevice", "failed", avd.name, {
-				id: avd.name,
-				detail: result.reason
-			});
-		} else if (result.status === "torn-down") {
-			console.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
-			recordGcResult("parkedDevice", "done", avd.name, {
-				id: avd.name,
-				bytes: avd.bytes
-			});
-		} else console.log(chalk.dim(`Skipped ${avd.name}; it is no longer parked.`));
-	}
-	return failures;
-}
-function deleteParkedSims(parkedSims, deps = {}) {
-	let failures = 0;
-	let emptied = 0;
-	for (const sim of parkedSims) {
-		if (sim.listed === null) {
-			failures++;
-			console.log(chalk.red(`Could not verify parked ios sim ${sim.name} (${sim.udid}); its pool record was kept.`));
-			recordGcResult("parkedDevice", "failed", sim.name, {
-				id: sim.udid,
-				detail: "Stim could not list simulators to verify it; its pool record was kept. Retry stim gc --delete."
-			});
-			continue;
-		}
-		try {
-			const teardown = sim.listed ? teardownParkedIosSim(sim.udid, {
-				label: sim.name,
-				deleteSim: deps.deleteParkedIosSim
-			}) : null;
-			if (!(sim.listed ? teardown?.status === "torn-down" : dropParked("ios", sim.udid))) {
-				if (teardown?.status === "failed") {
-					failures++;
-					console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${teardown.reason}`));
-					recordGcResult("parkedDevice", "failed", sim.name, {
-						id: sim.udid,
-						detail: teardown.reason
-					});
-				} else console.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
-				continue;
-			}
-			emptied++;
-			recordGcResult("parkedDevice", "done", sim.name, {
-				id: sim.udid,
-				bytes: sim.listed ? sim.bytes : null
-			});
-			console.log(chalk.green(sim.listed ? `Deleted parked ios sim ${sim.name} (${sim.udid})` : `Dropped the parked record for ${sim.name} (${sim.udid}); it is not on this machine.`));
-		} catch (err) {
-			failures++;
-			console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${err?.message || err}`));
-			recordGcResult("parkedDevice", "failed", sim.name, {
-				id: sim.udid,
-				detail: err?.message || String(err)
-			});
-		}
-	}
-	if (emptied) console.log(chalk.dim(`  emptied ${plural(emptied, "parked simulator")} from the pool`));
-	return failures;
-}
-function deviceSweepIsScoped() {
-	return Boolean(process.env.STIM_HOME);
-}
-function collectDeviceLeases(now) {
-	const expired = [];
-	const kept = [];
-	for (const entry of listLeaseFiles()) {
-		const lease = entry.lease;
-		if (!lease) {
-			kept.push({
-				name: entry.name,
-				path: entry.path,
-				reason: "it does not parse as a lease, so no run may take that device"
-			});
-			continue;
-		}
-		if (leaseIsExpired(lease, now)) {
-			expired.push(entry);
-			continue;
-		}
-		if (!existsSync$1(lease.holder)) kept.push({
-			name: entry.name,
-			path: entry.path,
-			reason: `${lease.holder} is not on this machine, but the lease runs until ${lease.expiresAt}`
-		});
-	}
-	return {
-		expired,
-		kept
-	};
-}
-function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords) {
-	let deleteFailures = 0;
-	function reap(d, onlyIfMissing = false) {
-		const r = d.kind === "ios" ? teardownOwnedIosSim(d.id, {
-			del: true,
-			label: d.name
-		}) : teardownOwnedAvd(d.name, {
-			del: true,
-			onlyIfMissing,
-			..."project" in d ? { owner: {
-				projectPath: d.project,
-				slot: d.slot
-			} } : {},
-			..."project" in d ? { onRemoved: () => {
-				if (clearDevice(d.project, d.kind, d.slot, d.id)) console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
-			} } : {},
-			..."orphanedDirectory" in d ? { orphanedDirectory: d.orphanedDirectory } : {}
-		});
-		const what = d.kind === "ios" ? `ios sim ${d.name} (${d.id})` : `android avd ${d.name}`;
-		const result = {
-			id: d.id,
-			bytes: d.bytes ?? null
-		};
-		if (r.status === "torn-down") {
-			console.log(chalk.green(`Deleted ${what}`));
-			recordGcResult("device", "done", d.name, result);
-		} else if (r.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to delete.`));
-		else if (r.status === "skipped") {
-			console.log(chalk.yellow(`Skipped ${what}: ${r.reason} -- left for a later gc`));
-			recordGcResult("device", "kept", d.name, {
-				...result,
-				detail: `${r.reason}; left for a later gc`
-			});
-		} else {
-			deleteFailures++;
-			console.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
-			recordGcResult("device", "failed", d.name, {
-				...result,
-				detail: r.reason
-			});
-		}
-		return r.status;
-	}
-	for (const d of orphanedDevices) reap(d);
-	for (const d of staleDevices) {
-		const status = reap(d);
-		if (d.kind === "ios" && (status === "torn-down" || status === "missing")) {
-			clearDevice(d.project, d.kind, d.slot, d.id);
-			console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
-		}
-	}
-	for (const r of staleDeviceRecords) if (r.kind === "android" && r.owned) reap({
-		...r,
-		name: r.id,
-		idleDays: 0
-	}, true);
-	else if (withConfigLock$1(() => {
-		if (r.kind === "android" && deviceSlotPlatforms(getProject(r.project), r.slot)?.android?.owned) return false;
-		return clearDevice(r.project, r.kind, r.slot, r.id);
-	})) {
-		console.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
-		recordGcResult("deviceRecord", "done", r.project, { id: r.id });
-	}
-	return deleteFailures;
-}
-//#endregion
-//#region src/commands/gc/idle.ts
-function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
-	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
-	const dead = new Set(deadProjects);
-	const found = [];
-	for (const [project, record] of Object.entries(config?.projects ?? {})) {
-		if (dead.has(project)) continue;
-		for (const { slot, platforms } of projectDeviceSlots(record)) {
-			const ios = platforms.ios;
-			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
-				kind: "ios",
-				id: ios.deviceUdid,
-				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
-				project,
-				slot,
-				activity: readActivity({
-					platform: "ios",
-					id: ios.deviceUdid,
-					slot,
-					workspace: project
-				})
-			});
-			const android = platforms.android;
-			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
-			if (android?.avdName && serial) found.push({
-				kind: "android",
-				id: android.avdName,
-				name: android.avdName,
-				project,
-				slot,
-				activity: readActivity({
-					platform: "android",
-					id: serial,
-					slot,
-					workspace: project
-				})
-			});
-		}
-	}
-	return found;
-}
-function findIdleDevices({ buildInProgress, now, ...inputs }) {
-	return findOwnedDeviceActivity(inputs).filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
-		kind,
-		id,
-		name,
-		project,
-		slot,
-		lastActivityAt: activity.lastActivityAt ?? null,
-		idleForMs: idleForMs(activity, now),
-		buildInProgress: buildInProgress(project)
-	}));
-}
-function idleShutdownCandidates(devices, idleMs) {
-	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
-}
-function parseIdleDuration(value) {
-	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
-	if (!match) return null;
-	const unit = {
-		m: 6e4,
-		h: 36e5,
-		d: 864e5
-	}[match[2]];
-	return Number(match[1]) * unit;
-}
-function workspaceBuildInProgress(project) {
-	const record = parseActiveBuild(readWorkspaceState$1(project)?.[ACTIVE_BUILD_KEY]);
-	if (!record) return false;
-	try {
-		return activeBuildState(record.claim) !== "stale";
-	} catch {
-		return true;
-	}
-}
-function deviceActivityInputs(config, sims, now) {
-	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
-	return {
-		config,
-		sims,
-		readActivity: createActivityReader({ now }),
-		androidSerial: (avdName) => {
-			try {
-				return resolve(avdName).serial ?? null;
-			} catch {
-				return null;
-			}
-		}
-	};
-}
-function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
-	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
-}
-function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
-	return findIdleDevices({
-		...deviceActivityInputs(config, sims, now),
-		deadProjects,
-		now,
-		buildInProgress: workspaceBuildInProgress
-	});
-}
-function idleDeviceLines(devices) {
-	if (devices.length === 0) return [];
-	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
-		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
-		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
-		const build = d.buildInProgress ? ", build in progress" : "";
-		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
-	})];
-}
-function shutDownIdleDevices(devices, idleMs, recollect) {
-	const candidates = idleShutdownCandidates(devices, idleMs);
-	const shutDown = [];
-	if (candidates.length === 0) {
-		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
-		return {
-			failures: 0,
-			shutDown
-		};
-	}
-	const fresh = idleShutdownCandidates(recollect(), idleMs);
-	let failures = 0;
-	for (const device of candidates) {
-		const what = `${device.kind} ${device.name}`;
-		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
-		if (!current) {
-			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
-			recordGcResult("idleDevice", "kept", device.name, {
-				id: device.id,
-				detail: `it is no longer idle for ${formatLongDuration(idleMs)}`
-			});
-			continue;
-		}
-		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
-			projectPath: device.project,
-			slot: device.slot
-		} });
-		if (outcome.status === "torn-down") {
-			shutDown.push(device);
-			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
-			recordGcResult("idleDevice", "done", device.name, {
-				id: device.id,
-				detail: `idle ${formatLongDuration(current.idleForMs)}`
-			});
-		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
-		else if (outcome.status === "skipped") {
-			console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
-			recordGcResult("idleDevice", "kept", device.name, {
-				id: device.id,
-				detail: outcome.reason
-			});
-		} else {
-			failures++;
-			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
-			recordGcResult("idleDevice", "failed", device.name, {
-				id: device.id,
-				detail: outcome.reason
-			});
-		}
-	}
-	return {
-		failures,
-		shutDown
-	};
-}
-//#endregion
-//#region src/budget.ts
-const MB = 1048576;
-const GB_IN_MB = 1024;
-const COMMITTED_MEMORY_SHARE = .6;
-const DEVICE_LIST_TIMEOUT_MS = 1e4;
-const USAGE_TIMEOUT_MS = 1e4;
-const BUDGET_SETTING_REMEDY = "Fix the value with `stim settings set <key> <value>`, or unset the environment variable. Run `stim guide settings` for the budget keys.";
-function valueAt(source, key) {
-	let node = source;
-	for (const part of key.split(".")) {
-		if (node === null || typeof node !== "object" || Array.isArray(node)) return void 0;
-		node = node[part];
-	}
-	return node;
-}
-function machineNumber(key, config, env) {
-	const setting = settingDefinition(key);
-	const fromEnv = setting.env ? env[setting.env] : void 0;
-	if (fromEnv !== void 0 && fromEnv !== "") {
-		const value = fromEnv.trim() === "" ? NaN : Number(fromEnv);
-		const problem = settingValueError(setting, value);
-		return problem ? {
-			value: void 0,
-			error: `Invalid ${setting.env} value ${JSON.stringify(fromEnv)}. Expected ${problem}.`
-		} : {
-			value,
-			error: null
-		};
-	}
-	if (env.STIM_HOME && typeof setting.scopedHomeValue === "number") return {
-		value: setting.scopedHomeValue,
-		error: null
-	};
-	const raw = valueAt(config, key);
-	if (raw === void 0) return {
-		value: typeof setting.default === "number" ? setting.default : void 0,
-		error: null
-	};
-	const problem = settingValueError(setting, raw);
-	return problem ? {
-		value: void 0,
-		error: `Invalid ${key} value ${JSON.stringify(raw)}. Expected ${problem}.`
-	} : {
-		value: raw,
-		error: null
-	};
-}
-function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem$1() / MB } = {}) {
-	const minFree = machineNumber("budget.minFreeDiskGb", config, env);
-	const hardFloor = machineNumber("budget.hardFloorDiskGb", config, env);
-	const memory = machineNumber("budget.maxCommittedMemoryGb", config, env);
-	const live = machineNumber("budget.maxLiveWorkspaces", config, env);
-	return {
-		budget: {
-			minFreeDiskMb: (minFree.value ?? 0) * GB_IN_MB,
-			hardFloorDiskMb: (hardFloor.value ?? 0) * GB_IN_MB,
-			maxCommittedMemoryMb: memory.value === void 0 ? Math.round(totalMemoryMb * COMMITTED_MEMORY_SHARE) : memory.value * GB_IN_MB,
-			maxLiveWorkspaces: live.value ?? 0
-		},
-		error: minFree.error ?? hardFloor.error ?? memory.error ?? live.error
-	};
-}
-function existingAncestor(path) {
-	let current = path;
-	while (!existsSync(current) && dirname(current) !== current) current = dirname(current);
-	return current;
-}
-function readVolumeSpace(paths) {
-	const seen = /* @__PURE__ */ new Set();
-	const volumes = [];
-	for (const path of paths) try {
-		const existing = existingAncestor(path);
-		const device = statSync(existing).dev;
-		if (seen.has(device)) continue;
-		seen.add(device);
-		const fs = statfsSync(existing);
-		volumes.push({
-			volume: volumeRootFor(path),
-			freeMb: fs.bavail * fs.bsize / MB
-		});
-	} catch {}
-	return volumes;
-}
-function estimateMemoryUse({ config, sims, androidSerial, supervisorRunning }) {
-	const simsByUdid = Object.fromEntries((sims ?? []).map((sim) => [sim.udid, sim]));
-	const runtime = (avdName) => {
-		if (!avdName) return null;
-		const serial = androidSerial(avdName);
-		return {
-			serial,
-			state: serial ? "detected" : "not-detected"
-		};
-	};
-	const states = Object.entries(config?.projects ?? {}).map(([path, project]) => {
-		const pid = supervisorRunning(path, project);
-		const slots = projectDeviceSlots(project);
-		return environmentState({
-			...project,
-			__path: path
-		}, {
-			simsByUdid,
-			simsAvailable: sims !== null,
-			metro: pid === null ? { missing: true } : { metro: { pid } },
-			androidRuntime: project.platforms?.android?.owned ? runtime(project.platforms.android.avdName) : null,
-			androidRuntimes: Object.fromEntries(slots.slice(1).map(({ slot, platforms }) => [slot, platforms.android?.owned ? runtime(platforms.android.avdName) : null]))
-		});
-	});
-	const { committedMb, liveCount } = capacity(states, 0);
-	return {
-		committedMb,
-		liveWorkspaces: liveCount
-	};
-}
-function listSims() {
-	try {
-		return listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-	} catch {
-		return null;
-	}
-}
-function snapshotSims(snapshot) {
-	try {
-		return snapshot.read().filter((sim) => sim.available);
-	} catch {
-		return null;
-	}
-}
-function runningSupervisorPid(path, project) {
-	const target = resolveSupervisorTarget({
-		state: readWorkspaceState$1(path)?.supervisor,
-		record: project.supervisor,
-		reservedPort: project.metroPort
-	});
-	return target.status === "ours" ? target.pid ?? null : null;
-}
-function readMemoryUse(simSnapshot) {
-	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
-	return estimateMemoryUse({
-		config: loadConfig$1(),
-		sims: simSnapshot ? snapshotSims(simSnapshot) : listSims(),
-		androidSerial: (avdName) => {
-			try {
-				return resolve(avdName).serial ?? null;
-			} catch {
-				return null;
-			}
-		},
-		supervisorRunning: runningSupervisorPid
-	});
-}
-function budgetShortfalls(budget, measure) {
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	return {
-		disk: floor > 0 ? measure.volumes.filter((v) => v.freeMb < floor) : [],
-		hardFloor: budget.hardFloorDiskMb > 0 ? measure.volumes.filter((v) => v.freeMb < budget.hardFloorDiskMb) : [],
-		memory: Boolean(budget.maxCommittedMemoryMb > 0 && measure.memory && measure.memory.committedMb > budget.maxCommittedMemoryMb),
-		workspaces: Boolean(budget.maxLiveWorkspaces > 0 && measure.memory && measure.memory.liveWorkspaces > budget.maxLiveWorkspaces)
-	};
-}
-const DISK_ONLY = ["workspace-outputs", "stale-cache-entries"];
-function reclaimPlan(short) {
-	const disk = short.disk.length > 0;
-	return [...disk || short.memory || short.workspaces ? ["idle-devices", "idle-dev-servers"] : [], ...disk ? DISK_ONLY : []];
-}
-function overBudget(short) {
-	return short.disk.length > 0 || short.memory || short.workspaces;
-}
-function isOtherWorkspace(root) {
-	const self = canonicalPath(root);
-	return (path) => canonicalPath(path) !== self;
-}
-function deviceLabel(device) {
-	return `${device.kind} ${device.name} in ${device.project}`;
-}
-function reclaimIdleDevices({ root, dryRun, note, now }) {
-	if (deviceSweepIsScoped()) {
-		note(chalk.dim(phaseLine("budget", "idle devices left alone: STIM_HOME scopes this config, devices are global")));
-		return {
-			targets: [],
-			failures: 0
-		};
-	}
-	const other = isOtherWorkspace(root);
-	const collect = (at) => idleShutdownCandidates(collectIdleDevices(loadConfig$1(), listSims() ?? [], [], at).filter((device) => other(device.project)), 0);
-	const idle = collect(now);
-	if (dryRun || idle.length === 0) return {
-		targets: idle.map(deviceLabel),
-		failures: 0
-	};
-	const { failures, shutDown } = shutDownIdleDevices(idle, 0, () => collect(Date.now()));
-	return {
-		targets: shutDown.map(deviceLabel),
-		failures
-	};
-}
-function idleSince(path, now) {
-	const activity = workspaceActivity(path, now);
-	const at = Date.parse(activity.lastActivityAt ?? "");
-	return activity.state === "idle" && Number.isFinite(at) ? at : null;
-}
-async function reclaimIdleDevServers({ root, dryRun, note, now }) {
-	const config = loadConfig$1();
-	const other = isOtherWorkspace(root);
-	const serving = Object.entries(config?.projects ?? {}).flatMap(([path, project]) => {
-		const pid = other(path) ? runningSupervisorPid(path, project) : null;
-		return pid !== null && !workspaceBuildInProgress(path) && idleSince(path, now) !== null ? [{
-			path,
-			pid
-		}] : [];
-	});
-	if (serving.length === 0) return {
-		targets: [],
-		failures: 0
-	};
-	const sims = listSims();
-	if (sims === null) {
-		note(chalk.dim(phaseLine("budget", "dev servers left alone: simulators could not be listed to prove them idle")));
-		return {
-			targets: [],
-			failures: 0
-		};
-	}
-	const busy = new Set(collectOwnedDeviceActivity(config, sims, now).filter((device) => device.activity.state !== "idle").map((device) => device.project));
-	const idle = serving.filter(({ path }) => !busy.has(path));
-	if (dryRun) return {
-		targets: idle.map(({ path }) => path),
-		failures: 0
-	};
-	const targets = [];
-	let failures = 0;
-	const stillIdle = (path, pid) => {
-		const project = loadConfig$1()?.projects?.[path];
-		return Boolean(project && runningSupervisorPid(path, project) === pid && !workspaceBuildInProgress(path) && idleSince(path, Date.now()) !== null);
-	};
-	for (const { path, pid } of idle) {
-		let run;
-		try {
-			run = await withIdleWorkspace(path, async () => {
-				try {
-					return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => stillIdle(path, pid) ? stopOwnedMetro(path, {
-						by: "budget reclaim",
-						workspace: root
-					}) : "busy", {
-						external: true,
-						waitMs: 0,
-						ownerPurpose: "budget reclaim"
-					});
-				} catch (error) {
-					if (workspaceProcessLockError(error)) return "starting";
-					throw error;
-				}
-			}, {
-				purpose: "budget reclaim",
-				supervisor: false
-			});
-		} catch (error) {
-			failures++;
-			note(chalk.red(`Could not stop the dev server of ${path}: ${error?.message || error}`));
-			continue;
-		}
-		if (!run.ran) {
-			note(chalk.yellow(`Kept the dev server of ${path}: ${run.reasons.join("; ")}`));
-			continue;
-		}
-		const stopped = run.value;
-		if (stopped === "busy" || stopped === "starting") {
-			const why = stopped === "busy" ? "it is no longer idle" : "a stim start holds its metro-start lock";
-			note(chalk.dim(`Kept the dev server of ${path}: ${why}`));
-		} else if (stopped.status === "stopped") {
-			targets.push(path);
-			note(chalk.green(`Stopped the idle dev server of ${path}`));
-		} else if ("reason" in stopped) {
-			if (stopped.status === "stuck") failures++;
-			note(chalk.yellow(`Kept the dev server of ${path}: ${stopped.reason}`));
-		}
-	}
-	return {
-		targets,
-		failures
-	};
-}
-async function reclaimWorkspaceOutputs({ root, dryRun, now, diskRecovered }) {
-	const other = isOtherWorkspace(root);
-	const report = collectWorkspaceOutputs({
-		olderThan: null,
-		now,
-		measure: false
-	});
-	const clearable = report.workspaces.flatMap((entry) => {
-		const project = entry.projectRoot;
-		const since = project !== null && entry.willClear && other(project) ? idleSince(project, now) : null;
-		return since === null ? [] : [{
-			entry,
-			since
-		}];
-	}).toSorted((a, b) => a.since - b.since).map(({ entry }) => entry);
-	if (dryRun) return {
-		targets: clearable.map((entry) => entry.projectRoot),
-		failures: 0
-	};
-	const targets = [];
-	let failures = 0;
-	for (const entry of clearable) {
-		const result = await clearWorkspaceOutputs({
-			...report,
-			workspaces: [entry]
-		}, {
-			olderThan: null,
-			now
-		});
-		failures += result.failures;
-		targets.push(...result.cleared);
-		if (diskRecovered()) break;
-	}
-	return {
-		targets,
-		failures
-	};
-}
-function cacheLabel(cache) {
-	return `${cache.name} ${cache.dir}`;
-}
-function trimmableCaches() {
-	return planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
-}
-function reclaimStaleCacheEntries({ dryRun }) {
-	const caches = trimmableCaches();
-	if (dryRun) return {
-		targets: caches.map(cacheLabel),
-		failures: 0
-	};
-	return {
-		targets: trimCaches(caches, 14).map(cacheLabel),
-		failures: 0
-	};
-}
-const STEPS = {
-	"idle-devices": reclaimIdleDevices,
-	"idle-dev-servers": reclaimIdleDevServers,
-	"workspace-outputs": reclaimWorkspaceOutputs,
-	"stale-cache-entries": reclaimStaleCacheEntries
-};
-const STEP_ACTIONS = {
-	"idle-devices": "shut down idle owned devices",
-	"idle-dev-servers": "stop idle dev servers",
-	"workspace-outputs": "clear build outputs of idle workspaces",
-	"stale-cache-entries": `trim cache entries unused for 14 days`
-};
-async function runStep(step, context) {
-	const log = console.log;
-	const exitCode = process.exitCode;
-	console.log = console.error;
-	try {
-		const result = await STEPS[step](context);
-		return process.exitCode === exitCode ? result : {
-			...result,
-			failures: result.failures + 1
-		};
-	} catch (error) {
-		context.note(chalk.red(phaseLine("budget", `${STEP_ACTIONS[step]} failed: ${error?.message || error}`)));
-		return {
-			targets: [],
-			failures: 1
-		};
-	} finally {
-		console.log = log;
-		process.exitCode = exitCode;
-	}
-}
-function spaceUsers() {
-	const home = homedir$1();
-	const candidates = [
-		["Stim state", getConfigDir()],
-		["shared build cache", sharedBuildCache()],
-		...platform() === "darwin" ? [["simulators", join(home, "Library", "Developer", "CoreSimulator", "Devices")], ["Xcode DerivedData", join(home, "Library", "Developer", "Xcode", "DerivedData")]] : [],
-		["Android emulators", join(home, ".android", "avd")]
-	];
-	const measured = /* @__PURE__ */ new Set();
-	const users = [];
-	for (const [label, path] of candidates) {
-		const canonical = canonicalPath(path);
-		if (measured.has(canonical) || [...measured].some((dir) => canonical.startsWith(`${dir}${sep}`))) continue;
-		measured.add(canonical);
-		if (!existsSync(path)) continue;
-		const bytes = measuredDirectorySize(path, { timeoutMs: USAGE_TIMEOUT_MS });
-		if (bytes) users.push({
-			label: `${label} ${path}`,
-			bytes
-		});
-	}
-	return users.toSorted((a, b) => b.bytes - a.bytes).map(({ label, bytes }) => `${label}: ${formatBytes(bytes)}`);
-}
-const DEFAULT_DEPS = {
-	volumes: readVolumeSpace,
-	memory: readMemoryUse,
-	step: runStep,
-	usage: spaceUsers,
-	now: Date.now
-};
-const LOW_DISK_REMEDY = "Run `stim gc` to see what else Stim can reclaim, then `stim gc --delete` (add `--cache all` to empty the shared caches, or `--worktrees` to remove finished worktrees). Free space outside Stim from the largest uses listed, or lower budget.hardFloorDiskGb.";
-function describeShortfall(budget, measure, short) {
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	return [
-		...short.disk.map((v) => `${formatSpace(v.freeMb)} free on ${v.volume}, below the ${formatSpace(floor)} floor`),
-		...short.memory && measure.memory ? [`roughly ${formatSpace(measure.memory.committedMb)} of memory committed, over the ${formatSpace(budget.maxCommittedMemoryMb)} budget`] : [],
-		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} active workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
-	];
-}
-async function enforceBudget({ root, note, dryRun = false, budget: resolved, simSnapshot }, overrides = {}) {
-	const deps = {
-		...DEFAULT_DEPS,
-		...overrides
-	};
-	let budget = resolved;
-	if (!budget) {
-		const read = resolveBudget();
-		if (read.error) return {
-			status: "invalid",
-			refusal: {
-				code: "STIM_BAD_ARG",
-				message: read.error,
-				remedy: BUDGET_SETTING_REMEDY
-			}
-		};
-		budget = read.budget;
-	}
-	const paths = [root, getConfigDir()];
-	const measureNow = () => ({
-		volumes: budget.minFreeDiskMb > 0 || budget.hardFloorDiskMb > 0 ? deps.volumes(paths) : [],
-		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory(simSnapshot) : null
-	});
-	let measure = measureNow();
-	let short = budgetShortfalls(budget, measure);
-	const reclaimed = [];
-	const plan = reclaimPlan(short);
-	if (plan.length) note(chalk.yellow(phaseLine("budget", `${describeShortfall(budget, measure, short).join("; ")}; ${dryRun ? "would reclaim" : "reclaiming"}`)));
-	for (const step of plan) {
-		if (!dryRun && (!overBudget(short) || DISK_ONLY.includes(step) && short.disk.length === 0)) break;
-		const freeBefore = measure.volumes.reduce((sum, v) => sum + v.freeMb, 0);
-		const result = await deps.step(step, {
-			root,
-			dryRun,
-			note,
-			now: deps.now(),
-			diskRecovered: () => budgetShortfalls(budget, {
-				volumes: deps.volumes(paths),
-				memory: null
-			}).disk.length === 0
-		});
-		if (!dryRun) {
-			simSnapshot?.invalidate();
-			measure = measureNow();
-			short = budgetShortfalls(budget, measure);
-		}
-		if (result.targets.length === 0 && result.failures === 0) continue;
-		const freedMb = Math.max(0, Math.round(measure.volumes.reduce((sum, v) => sum + v.freeMb, 0) - freeBefore));
-		reclaimed.push({
-			step,
-			...result,
-			...dryRun ? {} : { freedMb }
-		});
-		const outcome = dryRun ? result.targets.join(", ") : `${result.targets.length}${result.failures ? `, ${result.failures} failed` : ""} (${formatSpace(freedMb)} freed)`;
-		note(chalk.dim(phaseLine("budget", `${STEP_ACTIONS[step]}: ${outcome}`)));
-	}
-	if (!dryRun && short.hardFloor.length) {
-		const tight = short.hardFloor.map((v) => `${formatSpace(v.freeMb)} on ${v.volume}`).join(" and ");
-		const users = deps.usage();
-		return {
-			status: "refused",
-			reclaimed,
-			refusal: {
-				code: "STIM_LOW_DISK",
-				message: `Only ${tight} is free, below the ${formatSpace(budget.hardFloorDiskMb)} hard floor (budget.hardFloorDiskGb)${reclaimed.length ? " after reclaiming what Stim safely could" : ""}, so this run could fill the disk.` + (users.length ? ` Largest uses: ${users.join("; ")}.` : ""),
-				remedy: LOW_DISK_REMEDY
-			}
-		};
-	}
-	if (!dryRun && overBudget(short)) note(chalk.yellow(phaseLine("budget", `still over budget: ${describeShortfall(budget, measure, short).join("; ")}`)));
-	return {
-		status: "ok",
-		reclaimed,
-		budget,
-		measure,
-		short
-	};
-}
-async function peekBudget(root, overrides = {}) {
-	const outcome = await enforceBudget({
-		root,
-		note: () => {},
-		dryRun: true
-	}, {
-		...overrides,
-		step: async () => ({
-			targets: [],
-			failures: 0
-		})
-	});
-	if (outcome.status !== "ok") return outcome.refusal.message;
-	const shortfall = describeShortfall(outcome.budget, outcome.measure, outcome.short);
-	return shortfall.length ? shortfall.join("; ") : null;
-}
-async function budgetGate(args, overrides = {}) {
-	const outcome = await enforceBudget(args, overrides);
-	return {
-		reclaimed: "reclaimed" in outcome ? outcome.reclaimed : [],
-		refusal: outcome.status === "ok" ? null : outcome.refusal
-	};
-}
-const gb = (mb) => Math.round(mb / GB_IN_MB * 10) / 10;
-function budgetFindings(budget, measure, short, plan) {
-	const findings = [];
-	const steps = plan.length ? plan.map((entry) => `${STEP_ACTIONS[entry.step]} (${entry.targets.join(", ")})`).join("; then ") : "nothing Stim can reclaim on its own right now";
-	if (short.disk.length) {
-		const refuses = short.hardFloor.length ? ` Below ${formatSpace(budget.hardFloorDiskMb)} it refuses with STIM_LOW_DISK when reclaiming does not free enough.` : "";
-		findings.push({
-			level: "cost",
-			title: "Free disk is below the Stim budget",
-			detail: `${describeShortfall(budget, measure, {
-				...short,
-				memory: false,
-				workspaces: false
-			}).join("; ")}. The next ios, android or start will first ${steps}.${refuses}`,
-			fix: "Run `stim gc` to see what Stim can reclaim, then `stim gc --delete`. Free space outside Stim, or lower budget.minFreeDiskGb."
-		});
-	}
-	if (short.memory || short.workspaces) findings.push({
-		level: "note",
-		title: "Active environments are over the memory budget",
-		detail: `${describeShortfall(budget, measure, {
-			...short,
-			disk: []
-		}).join("; ")}. The next ios, android or start shuts down idle owned devices and stops idle dev servers in other workspaces first.`,
-		fix: "Run `stim status` to see what is active, and `stim stop` in workspaces you own that you no longer need."
-	});
-	return findings;
-}
-async function inspectBudget(root, deps = {}) {
-	const read = resolveBudget();
-	if (read.error) return {
-		report: null,
-		findings: [{
-			level: "cost",
-			title: "A budget setting is invalid",
-			detail: read.error,
-			fix: BUDGET_SETTING_REMEDY
-		}]
-	};
-	const outcome = await enforceBudget({
-		root,
-		note: () => {},
-		dryRun: true,
-		budget: read.budget
-	}, deps);
-	if (outcome.status !== "ok") return {
-		report: null,
-		findings: []
-	};
-	const { budget, measure, short, reclaimed } = outcome;
-	return {
-		report: {
-			budget: {
-				minFreeDiskGb: gb(budget.minFreeDiskMb),
-				hardFloorDiskGb: gb(budget.hardFloorDiskMb),
-				maxCommittedMemoryGb: gb(budget.maxCommittedMemoryMb),
-				maxLiveWorkspaces: budget.maxLiveWorkspaces
-			},
-			volumes: measure.volumes.map((v) => ({
-				volume: v.volume,
-				freeGb: gb(v.freeMb)
-			})),
-			memory: measure.memory ? {
-				committedGb: gb(measure.memory.committedMb),
-				liveWorkspaces: measure.memory.liveWorkspaces
-			} : null,
-			plan: reclaimed
-		},
-		findings: budgetFindings(budget, measure, short, reclaimed)
-	};
-}
-function budgetLine(report) {
-	const { budget } = report;
-	return `${report.volumes.length ? `${report.volumes.map((v) => `${v.freeGb} GB free on ${v.volume}`).join(", ")} (reclaims below ${Math.max(budget.minFreeDiskGb, budget.hardFloorDiskGb)} GB, ${budget.hardFloorDiskGb ? `refuses below ${budget.hardFloorDiskGb} GB` : "never refuses"})` : "disk budget off"}; ${report.memory ? `roughly ${report.memory.committedGb} GB of a ${budget.maxCommittedMemoryGb} GB memory budget committed` : "memory budget off"}`;
-}
-//#endregion
-export { memoryWorkPending as $, findStaleProjectDevices as A, createRunRecorder as At, previewScopedEmptying as B, deleteProjectDevices as C, bundlingActivity as Ct, eraseParkedDevices as D, recordFinishedBuild as Dt, deviceSweepIsScoped as E, recordBuildPhase as Et, includesParkedDevices as F, recordRunStats as Ft, GRADLE_DAEMONS_KIND as G, selectsBeyondCaches as H, includesRecordings as I, statsProjectKey$1 as It, inspectWatchmanMemory as J, WATCHMAN_KIND as K, includesWorkspaceOutputs as L, withAndroidAvdSizes as M, readStats$1 as Mt, emptyCaches as N, recordCapacityRefusal as Nt, findOrphanedDevices as O, startBuildProgress as Ot, includesArchives as P, recordCapacityWait as Pt, memorySweepIsScoped as Q, isWorkspacesScope as R, deleteParkedSims as S, buildStatusLine as St, describeUnverifiableDevices as T, parseActiveBuild as Tt, trimCaches as U, selectCaches as V, parseArchiveSelector as W, memoryLines as X, memoryCacheKind as Y, memoryScope as Z, DEVICE_LIST_TIMEOUT_MS$1 as _, withdrawDevServerStopRequest as _t, inspectBudget as a, discoverCaches as at, collectParkedSims as b, activeBuildState as bt, readVolumeSpace as c, stopOwnedMetroForReset as ct, collectIdleDevices as d, devServerStopLevel as dt, reclaimMemory as et, collectOwnedDeviceActivity as f, devServerStopRecord as ft, workspaceBuildInProgress as g, vanishedSupervisorMessage as gt, shutDownIdleDevices as h, requestDevServerStop as ht, enforceBudget as i, readFootprints as it, unverifiedDeviceCommand as j, readRunEstimates as jt, findStaleDeviceRecords as k, tapBuildLog as kt, resolveBudget as l, describeDevServerStop as lt, parseIdleDuration as m, metroLastStop as mt, budgetLine as n, phase as nt, machineNumber as o, pruneCache as ot, idleDeviceLines as p, logVanishedSupervisor as pt, collectMemoryReport as q, cacheLabel as r, attributeMachineUsage as rt, peekBudget as s, sizeCaches as st, budgetGate as t, scopedMemoryReport as tt, trimmableCaches as u, describeMetroLastStop as ut, collectDeviceLeases as v, ACTIVE_BUILD_KEY as vt, describeParkedSims as w, estimateBuild as wt, deleteParkedAvds as x, buildReport as xt, collectParkedAvds as y, NO_BUILD_PROGRESS as yt, planCacheEmptying as z };