stim 1.14.0 → 1.16.0

package/dist/budget-DjrURfQn.mjs

@@ -0,0 +1,2700 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { A as directorySize, D as withConfigLock$1, F as volumeRootFor, H as projectDeviceSlots, M as isOnMountedVolume, P as measuredDirectorySize, _ as loadConfig$1, a as clearDevice, d as getConfigDir, j as formatBytes, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { i as registeredCaches } from "./cache-manifest-DnUHBJaU.mjs";
+import { l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-DnJMdEY-.mjs";
+import { l as resolveProjectMetro, r as killMetroTree } from "./metro-BeK1ZPz1.mjs";
+import { d as sharedBuildCache, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { a as capacity, l as environmentState, u as formatSpace } from "./status-BuvBFeII.mjs";
+import { i as recordGcResult, n as withIdleWorkspace, o as canonicalPath } from "./in-use-DvBw0Kxo.mjs";
+import { i as createDeviceProcessTables, p as workspaceActivity } from "./activity-BxwdD81S.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-D-hLqx1b.mjs";
+import { n as listBuildSlots } from "./build-slots-rUk77xqh.mjs";
+import { l as readPidFile, s as clearWorkspaceSupervisor } from "./state-DcW6vOd_.mjs";
+import { C as parseSubscriberNames, D as parseWatchmanPid, E as parseWatchmanClients, T as parseWatchRoots, i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices, w as parseTriggerCount } from "./idle-DYVymG92.mjs";
+import { A as listAvds, I as ownedAvdDirectory, at as isStimOwnedSim, ct as dropParked, it as isStimOwnedAvd, pt as readParked, z as ownedAvdSerialResolver } from "./android-B_NumVyQ.mjs";
+import { _ as parseRuntimeVersion, f as listIosDeviceTypes, u as listAllIosSims } from "./ios-BaInn3sW.mjs";
+import { c as teardownParkedIosSim, i as teardownOwnedAvd, n as eraseParkedIosSim, o as teardownOwnedIosSim, s as teardownParkedAvd, t as eraseParkedAvd } from "./teardown-CL6vDs2Y.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { a as collectWorkspaceOutputs, r as clearWorkspaceOutputs } from "./workspaces-BV4pdHFz.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-CidxIqup.mjs";
+import { existsSync, readFileSync, statSync, statfsSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { homedir, tmpdir } from "os";
+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 { METRO_NAMED_CACHE_LAYOUT, compiledHelper, configDir } from "@stim-cli/core";
+import { MACHINE_OWNER_KINDS, buildWorkerRoot, loadConfig, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
+import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
+import chalk from "chalk";
+//#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) }));
+}
+function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
+	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"
+	};
+	const entries = cache.files ?? entriesAtDepth(cache.dir, cache.entriesDepth ?? 1);
+	let removed = 0;
+	let bytes = 0;
+	let failed = 0;
+	for (const entry of entries) {
+		let used;
+		let size;
+		try {
+			const st = statSync$1(entry);
+			used = Math.max(st.atimeMs, st.mtimeMs);
+			size = st.isDirectory() ? directorySize(entry) : st.size;
+		} catch {
+			continue;
+		}
+		if (used >= cutoff) continue;
+		try {
+			rmSync$1(entry, {
+				recursive: true,
+				force: true
+			});
+			removed++;
+			bytes += size;
+		} catch {
+			failed++;
+		}
+	}
+	return {
+		removed,
+		bytes,
+		failed,
+		skipped: null
+	};
+}
+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 = root.build.platform === "ios" ? "iOS build" : "Android build";
+			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/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) {
+	const wanted = name?.trim().toLowerCase();
+	return Boolean(wanted && (wanted === "archived" || wanted.startsWith("archived:") || [
+		"archived-logs",
+		"archived-recordings",
+		"archived-agent"
+	].includes(wanted)));
+}
+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) {
+	if (Array.isArray(cache.files)) return false;
+	const dir = canonicalPath(cache.dir);
+	if (dirname$1(dir) === dir) return false;
+	return ![
+		homedir(),
+		tmpdir(),
+		getConfigDir()
+	].map(canonicalPath).includes(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/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/budget.ts
+const MB = 1048576;
+const GB_IN_MB = 1024;
+const COMMITTED_MEMORY_SHARE = .6;
+const STALE_CACHE_DAYS = 14;
+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 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() {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return estimateMemoryUse({
+		config: loadConfig$1(),
+		sims: 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 reclaimStaleCacheEntries({ dryRun }) {
+	const caches = planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+	if (dryRun) return {
+		targets: caches.map(cacheLabel),
+		failures: 0
+	};
+	return {
+		targets: trimCaches(caches, STALE_CACHE_DAYS).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 ${STALE_CACHE_DAYS} 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} live workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
+	];
+}
+async function enforceBudget({ root, note, dryRun = false, budget: resolved }, 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() : 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) {
+			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 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: "Live 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 live, 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 { isWorkspacesScope as A, memoryCacheKind as B, unverifiedDeviceCommand as C, includesParkedDevices as D, includesArchives as E, trimCaches as F, reclaimMemory as G, memoryScope as H, GRADLE_DAEMONS_KIND as I, attributeMachineUsage as J, scopedMemoryReport as K, WATCHMAN_KIND as L, previewScopedEmptying as M, selectCaches as N, includesRecordings as O, selectsBeyondCaches as P, collectMemoryReport as R, findStaleProjectDevices as S, emptyCaches as T, memorySweepIsScoped as U, memoryLines as V, memoryWorkPending as W, discoverCaches as X, readFootprints as Y, sizeCaches as Z, describeUnverifiableDevices as _, machineNumber as a, findOrphanedDevices as b, stopOwnedMetroForReset as c, collectParkedAvds as d, collectParkedSims as f, describeParkedSims as g, deleteProjectDevices as h, inspectBudget as i, planCacheEmptying as j, includesWorkspaceOutputs as k, DEVICE_LIST_TIMEOUT_MS$1 as l, deleteParkedSims as m, budgetLine as n, readVolumeSpace as o, deleteParkedAvds as p, phase as q, enforceBudget as r, resolveBudget as s, budgetGate as t, collectDeviceLeases as u, deviceSweepIsScoped as v, withAndroidAvdSizes as w, findStaleDeviceRecords as x, eraseParkedDevices as y, inspectWatchmanMemory as z };