stim 1.11.0 → 1.13.0

package/dist/budget-E5o91NR1.mjs

@@ -0,0 +1,1739 @@
+import { B as deviceSlotPlatforms, E as withConfigLock$1, F as measuredDirectorySize, I as volumeRootFor, M as formatBytes, N as isOnMountedVolume, O as process_identity_exports, P as listMountedVolumes, U as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as directorySize, o as clearSupervisor, p as getProject } from "./config-0jCcMM0E.mjs";
+import { i as registeredCaches } from "./cache-manifest-DWPF4RKJ.mjs";
+import { C as sharedBuildCache, N as workspaceName$1, c as resolveProjectMetro, h as readWorkspaceState$1, k as workspaceDir, n as killMetroTree, y as workspaceLastUsed } from "./metro-BPeY1YMh.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { s as clearWorkspaceSupervisor } from "./state-DwAU2_-D.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-n7tnJsI8.mjs";
+import { l as phaseLine, u as plural } from "./command-output-BIL7rlX7.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-CL9dZf73.mjs";
+import { o as workspaceActivity } from "./activity-DfVKZTEB.mjs";
+import { F as ownedAvdDirectory, R as ownedAvdSerialResolver, at as dropParked, k as listAvds, lt as readParked, nt as isStimOwnedSim, tt as isStimOwnedAvd } from "./android-qx_31wJo.mjs";
+import { f as teardownOwnedAvd, g as teardownParkedIosSim, h as teardownParkedAvd, m as teardownOwnedIosSim, p as teardownOwnedBrowser, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
+import { d as listIosDeviceTypes, g as parseRuntimeVersion, l as listAllIosSims } from "./ios-CmEzZiOj.mjs";
+import { c as recordGcResult, i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices } from "./idle-DxLi5OkN.mjs";
+import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-wYEaKQM9.mjs";
+import { c as formatSpace, r as capacity, s as environmentState } from "./status-sszP4XKU.mjs";
+import { existsSync, statSync, statfsSync } from "node:fs";
+import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
+import { isJsonObject, readJsonFile, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { dirname as dirname$1, join as join$1, sep as sep$1 } from "node:path";
+import { homedir, tmpdir } from "os";
+import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
+import chalk from "chalk";
+//#region src/supervisor/cache-reset.ts
+async function stopOwnedMetro(root) {
+	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
+	};
+	if (!killMetroTree(target.pid, target.processToken) || !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);
+	switch (stopped.status) {
+		case "unverified": throw supervisorError("STIM_SUPERVISOR_EXITED", `Cannot reset Metro: ${stopped.reason}.`, "Stop it with the tool that started it, then retry. Stim leaves unverified processes alone.");
+		case "external": throw supervisorError("STIM_SUPERVISOR_EXITED", "Cannot reset an externally started dev server.", "Stop it with the tool that started it, then retry `stim start --reset-cache`.");
+		case "stuck": throw supervisorError("STIM_SUPERVISOR_EXITED", "The owned Metro supervisor could not be stopped for a cache reset.", "Inspect `stim status` and `stim logs`, then retry. No cache reset was recorded.");
+		case "port-occupied": throw supervisorError("STIM_SUPERVISOR_EXITED", `Port ${getProject(root)?.metroPort} is still occupied after stopping Metro.`, "Inspect the listener before retrying. Stim does not terminate unrecorded processes.");
+	}
+}
+//#endregion
+//#region src/cache/caches.ts
+function xcodeDerivedDataRoot() {
+	return join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+}
+function compilationCache() {
+	const dir = join(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(homedir(), ".gradle");
+	const dir = resolve(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(root, n));
+		if (uid !== void 0 && st.uid !== uid) continue;
+		files.push(join(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 mergeCacheDescriptors([...registered, ...detected], gradleDir);
+}
+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(child) === dir || canonicalCacheDir(dirname(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(parent, child);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function canonicalCacheDir(dir) {
+	try {
+		return realpathSync$1(dir);
+	} catch {
+		return resolve(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(parent, name));
+		}
+		level = next;
+	}
+	return level;
+}
+//#endregion
+//#region src/commands/gc/caches.ts
+const DAY_MS$2 = 864e5;
+function cacheSweepIsScoped() {
+	return Boolean(process.env.STIM_HOME);
+}
+function isInsideConfigDir(dir) {
+	const root = canonicalPath(getConfigDir());
+	const target = canonicalPath(dir);
+	const rel = relative(root, target);
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(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";
+function includesWorkspaceOutputs(name) {
+	const wanted = name?.trim().toLowerCase();
+	return !wanted || wanted === EVERY_CACHE || wanted === WORKSPACE_OUTPUTS;
+}
+function selectCaches(caches, name) {
+	if (!name) return caches;
+	const wanted = name.trim().toLowerCase();
+	if (wanted === EVERY_CACHE) return caches;
+	if (wanted === WORKSPACE_OUTPUTS) return [];
+	return caches.filter((c) => c.name.toLowerCase().includes(wanted) || c.dir.toLowerCase().includes(wanted));
+}
+function planCacheEmptying(caches, all) {
+	const annotated = caches.map((c) => Object.assign({}, c, { machineGlobal: machineGlobalReason(c) }));
+	if (!all) return annotated;
+	return annotated.map((c) => {
+		if (c.prune === "report-only") return Object.assign({}, c, {
+			willEmpty: false,
+			emptySkipped: "report-only shared cache; Stim never deletes it"
+		});
+		if (c.machineGlobal) return Object.assign({}, c, {
+			willEmpty: false,
+			emptySkipped: c.machineGlobal
+		});
+		if (!ownsItsDirectory(c)) return Object.assign({}, c, {
+			willEmpty: false,
+			emptySkipped: `${c.dir} is not a directory this cache owns`
+		});
+		return Object.assign({}, c, {
+			willEmpty: true,
+			emptySkipped: null
+		});
+	});
+}
+function ownsItsDirectory(cache) {
+	if (Array.isArray(cache.files)) return false;
+	const dir = canonicalPath(cache.dir);
+	if (dirname(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$2
+	});
+	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(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$1 = 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$1;
+	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(path)) continue;
+		const touched = lastTouched(path);
+		if (!Number.isFinite(touched) || touched >= cutoff) continue;
+		const idleDays = Math.floor((now - touched) / DAY_MS$1);
+		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,
+			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$1;
+	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,
+			bytes,
+			listed: avds === null ? null : avds.includes(record.name)
+		};
+	});
+}
+function deleteParkedAvds(avds) {
+	let failures = 0;
+	for (const avd of avds) {
+		if (avd.listed === null) {
+			failures++;
+			console.log(chalk.red(`Could not verify parked android emulator ${avd.name}; its pool record was kept.`));
+			recordGcResult("parkedDevice", "failed", avd.name, {
+				id: avd.name,
+				detail: "Stim could not list emulators to verify it; its pool record was kept. Retry stim gc --delete."
+			});
+			continue;
+		}
+		const result = teardownParkedAvd(avd.name);
+		if (result.status === "failed") {
+			failures++;
+			console.log(chalk.red(`Failed to delete parked android emulator ${avd.name}: ${result.reason}`));
+			recordGcResult("parkedDevice", "failed", avd.name, {
+				id: avd.name,
+				detail: result.reason
+			});
+		} else if (result.status === "torn-down") {
+			console.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
+			recordGcResult("parkedDevice", "done", avd.name, {
+				id: avd.name,
+				bytes: avd.bytes
+			});
+		} else console.log(chalk.dim(`Skipped ${avd.name}; it is no longer parked.`));
+	}
+	return failures;
+}
+function deleteParkedSims(parkedSims, deps = {}) {
+	let failures = 0;
+	let emptied = 0;
+	for (const sim of parkedSims) {
+		if (sim.listed === null) {
+			failures++;
+			console.log(chalk.red(`Could not verify parked ios sim ${sim.name} (${sim.udid}); its pool record was kept.`));
+			recordGcResult("parkedDevice", "failed", sim.name, {
+				id: sim.udid,
+				detail: "Stim could not list simulators to verify it; its pool record was kept. Retry stim gc --delete."
+			});
+			continue;
+		}
+		try {
+			const teardown = sim.listed ? teardownParkedIosSim(sim.udid, {
+				label: sim.name,
+				deleteSim: deps.deleteParkedIosSim
+			}) : null;
+			if (!(sim.listed ? teardown?.status === "torn-down" : dropParked("ios", sim.udid))) {
+				if (teardown?.status === "failed") {
+					failures++;
+					console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${teardown.reason}`));
+					recordGcResult("parkedDevice", "failed", sim.name, {
+						id: sim.udid,
+						detail: teardown.reason
+					});
+				} else console.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
+				continue;
+			}
+			emptied++;
+			recordGcResult("parkedDevice", "done", sim.name, {
+				id: sim.udid,
+				bytes: sim.listed ? sim.bytes : null
+			});
+			console.log(chalk.green(sim.listed ? `Deleted parked ios sim ${sim.name} (${sim.udid})` : `Dropped the parked record for ${sim.name} (${sim.udid}); it is not on this machine.`));
+		} catch (err) {
+			failures++;
+			console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${err?.message || err}`));
+			recordGcResult("parkedDevice", "failed", sim.name, {
+				id: sim.udid,
+				detail: err?.message || String(err)
+			});
+		}
+	}
+	if (emptied) console.log(chalk.dim(`  emptied ${plural(emptied, "parked simulator")} from the pool`));
+	return failures;
+}
+function deviceSweepIsScoped() {
+	return Boolean(process.env.STIM_HOME);
+}
+function collectDeviceLeases(now) {
+	const expired = [];
+	const kept = [];
+	for (const entry of listLeaseFiles()) {
+		const lease = entry.lease;
+		if (!lease) {
+			kept.push({
+				name: entry.name,
+				path: entry.path,
+				reason: "it does not parse as a lease, so no run may take that device"
+			});
+			continue;
+		}
+		if (leaseIsExpired(lease, now)) {
+			expired.push(entry);
+			continue;
+		}
+		if (!existsSync$1(lease.holder)) kept.push({
+			name: entry.name,
+			path: entry.path,
+			reason: `${lease.holder} is not on this machine, but the lease runs until ${lease.expiresAt}`
+		});
+	}
+	return {
+		expired,
+		kept
+	};
+}
+function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords) {
+	let deleteFailures = 0;
+	function reap(d, onlyIfMissing = false) {
+		const r = d.kind === "ios" ? teardownOwnedIosSim(d.id, {
+			del: true,
+			label: d.name
+		}) : teardownOwnedAvd(d.name, {
+			del: true,
+			onlyIfMissing,
+			..."project" in d ? { owner: {
+				projectPath: d.project,
+				slot: d.slot
+			} } : {},
+			..."project" in d ? { onRemoved: () => {
+				if (clearDevice(d.project, d.kind, d.slot, d.id)) console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
+			} } : {},
+			..."orphanedDirectory" in d ? { orphanedDirectory: d.orphanedDirectory } : {}
+		});
+		const what = d.kind === "ios" ? `ios sim ${d.name} (${d.id})` : `android avd ${d.name}`;
+		const result = {
+			id: d.id,
+			bytes: d.bytes ?? null
+		};
+		if (r.status === "torn-down") {
+			console.log(chalk.green(`Deleted ${what}`));
+			recordGcResult("device", "done", d.name, result);
+		} else if (r.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to delete.`));
+		else if (r.status === "skipped") {
+			console.log(chalk.yellow(`Skipped ${what}: ${r.reason} -- left for a later gc`));
+			recordGcResult("device", "kept", d.name, {
+				...result,
+				detail: `${r.reason}; left for a later gc`
+			});
+		} else {
+			deleteFailures++;
+			console.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
+			recordGcResult("device", "failed", d.name, {
+				...result,
+				detail: r.reason
+			});
+		}
+		return r.status;
+	}
+	for (const d of orphanedDevices) reap(d);
+	for (const d of staleDevices) {
+		const status = reap(d);
+		if (d.kind === "ios" && (status === "torn-down" || status === "missing")) {
+			clearDevice(d.project, d.kind, d.slot, d.id);
+			console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
+		}
+	}
+	for (const r of staleDeviceRecords) if (r.kind === "android" && r.owned) reap({
+		...r,
+		name: r.id,
+		idleDays: 0
+	}, true);
+	else if (withConfigLock$1(() => {
+		if (r.kind === "android" && deviceSlotPlatforms(getProject(r.project), r.slot)?.android?.owned) return false;
+		return clearDevice(r.project, r.kind, r.slot, r.id);
+	})) {
+		console.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
+		recordGcResult("deviceRecord", "done", r.project, { id: r.id });
+	}
+	return deleteFailures;
+}
+//#endregion
+//#region src/commands/gc/workspaces.ts
+function workspacesRoot() {
+	return join(getConfigDir(), "workspaces");
+}
+function isInsideWorkspaces(dir) {
+	const rel = relative(canonicalPath(workspacesRoot()), canonicalPath(dir));
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function readRecordedRoot(dir, name) {
+	let parsed;
+	try {
+		parsed = readJsonFile(join(dir, "workspace.json"));
+	} catch (error) {
+		return {
+			projectRoot: null,
+			problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
+		};
+	}
+	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
+	if (typeof projectRoot !== "string" || !isAbsolute(projectRoot)) return {
+		projectRoot: null,
+		problem: "its workspace.json records no absolute project root"
+	};
+	if (workspaceName$1(projectRoot) !== name) return {
+		projectRoot: null,
+		problem: `its workspace.json records ${projectRoot}, whose workspace directory has another name`
+	};
+	return {
+		projectRoot,
+		problem: null
+	};
+}
+function listWorkspaceDirs() {
+	const root = workspacesRoot();
+	let names;
+	try {
+		names = readdirSync$1(root).toSorted();
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const name of names) {
+		const dir = join(root, name);
+		try {
+			if (!statSync$1(dir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		entries.push({
+			dir,
+			...readRecordedRoot(dir, name)
+		});
+	}
+	return entries;
+}
+function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse }) {
+	const orphaned = [];
+	const skipped = [];
+	for (const { dir, projectRoot, problem } of entries) {
+		if (projectRoot === null) {
+			skipped.push({
+				dir,
+				reason: `workspace directory not resolved: ${problem ?? "unknown project root"}`
+			});
+			continue;
+		}
+		const present = exists(projectRoot);
+		if (present === null) {
+			skipped.push({
+				dir,
+				reason: `cannot tell whether its project root ${projectRoot} still exists`
+			});
+			continue;
+		}
+		if (present) continue;
+		if (registryKeys.some((key) => isPathPrefix(projectRoot, key))) continue;
+		if (!isMounted(projectRoot)) {
+			skipped.push({
+				dir,
+				reason: `the volume of its project root ${projectRoot} is not mounted`
+			});
+			continue;
+		}
+		const reasons = inUse(projectRoot);
+		if (reasons.length) {
+			skipped.push({
+				dir,
+				reason: `its project root ${projectRoot} is gone, but ${reasons.join("; ")}`
+			});
+			continue;
+		}
+		orphaned.push({
+			dir,
+			projectRoot
+		});
+	}
+	return {
+		orphaned,
+		skipped
+	};
+}
+function rootPresence(path) {
+	try {
+		lstatSync$1(path);
+		return true;
+	} catch (error) {
+		const code = error?.code;
+		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
+	}
+}
+function collectOrphanedWorkspaces(registryKeys, mountedVolumes) {
+	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
+		registryKeys,
+		exists: rootPresence,
+		isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
+		inUse: (root) => workspaceInUse(root)
+	});
+	return {
+		orphaned: classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })),
+		skipped: classified.skipped
+	};
+}
+const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift.";
+const WORKSPACE_OUTPUT_DIRS = [
+	"derived-data",
+	"gradle-build",
+	"android-cas",
+	"cache-provider"
+];
+const DAY_MS = 864e5;
+function planWorkspaceOutputs(entries, { olderThan, now }) {
+	return entries.map(({ dir, projectRoot, problem, bytes, lastUsed, inUse }) => {
+		const idleDays = Number.isFinite(lastUsed) ? Math.max(0, Math.floor((now - lastUsed) / DAY_MS)) : null;
+		const [keptCode, keptReason] = projectRoot === null ? ["unresolved", `workspace directory not resolved: ${problem ?? "unknown project root"}`] : inUse.length ? ["in-use", `in use: ${inUse.join("; ")}`] : olderThan === null ? [null, null] : idleDays === null ? ["last-use-unknown", "its last use is unknown"] : idleDays < olderThan ? ["recently-used", `used ${idleDays}d ago, within --older-than ${olderThan}`] : [null, null];
+		return {
+			dir,
+			projectRoot,
+			bytes,
+			idleDays,
+			willClear: keptCode === null,
+			keptCode,
+			keptReason
+		};
+	});
+}
+const SIZE_TIMEOUT_MS = 6e4;
+function sizeOf(dir) {
+	return measuredDirectorySize(dir, { timeoutMs: SIZE_TIMEOUT_MS });
+}
+function outputPaths(dir) {
+	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync$1(path));
+}
+function outputBytes(paths) {
+	let total = 0;
+	for (const path of paths) {
+		const size = sizeOf(path);
+		if (size === null) return null;
+		total += size;
+	}
+	return total;
+}
+function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true }) {
+	const mountedVolumes = listMountedVolumes();
+	const entries = listWorkspaceDirs().filter((entry) => !exclude.includes(entry.dir)).filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => Object.assign({}, entry, { paths: outputPaths(entry.dir) })).filter((entry) => entry.paths.length > 0).map(({ paths, ...entry }) => Object.assign({}, entry, { bytes: measure ? outputBytes(paths) : null })).map((entry) => Object.assign({}, entry, {
+		lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
+		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
+	}));
+	return {
+		root: workspacesRoot(),
+		workspaces: planWorkspaceOutputs(entries, {
+			olderThan,
+			now
+		})
+	};
+}
+async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
+	let failures = 0;
+	let cleared = 0;
+	const clearedRoots = [];
+	for (const entry of report.workspaces) {
+		const root = entry.projectRoot;
+		if (!entry.willClear || root === null) {
+			if (entry.keptReason) {
+				console.log(chalk.dim(`Kept the build outputs of ${root ?? entry.dir}: ${entry.keptReason}`));
+				recordGcResult("workspaceOutputs", "kept", root ?? entry.dir, {
+					bytes: entry.bytes,
+					detail: entry.keptReason
+				});
+			}
+			continue;
+		}
+		let run;
+		try {
+			run = await withIdleWorkspace(root, () => {
+				const [again] = planWorkspaceOutputs([{
+					...entry,
+					problem: null,
+					lastUsed: workspaceLastUsed(root),
+					inUse: []
+				}], {
+					olderThan,
+					now
+				});
+				if (again?.keptReason) return again.keptReason;
+				for (const name of WORKSPACE_OUTPUT_DIRS) rmSync$1(join(entry.dir, name), {
+					recursive: true,
+					force: true
+				});
+				return null;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not clear the build outputs of ${root}: ${error?.message || String(error)}`));
+			recordGcResult("workspaceOutputs", "failed", root, {
+				bytes: entry.bytes,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		const kept = run.ran ? run.value : `in use: ${run.reasons.join("; ")}`;
+		if (kept) {
+			console.log(chalk.yellow(`Kept the build outputs of ${root}: ${kept}`));
+			recordGcResult("workspaceOutputs", "kept", root, {
+				bytes: entry.bytes,
+				detail: kept
+			});
+			continue;
+		}
+		cleared += entry.bytes ?? 0;
+		clearedRoots.push(root);
+		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+		recordGcResult("workspaceOutputs", "done", root, { bytes: entry.bytes });
+	}
+	if (cleared) console.log(chalk.dim(`Cleared ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
+	return {
+		failures,
+		cleared: clearedRoots
+	};
+}
+function stillOrphaned({ dir, projectRoot }) {
+	if (readRecordedRoot(dir, basename(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
+	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
+}
+async function deleteOrphanedWorkspaces(orphaned) {
+	let failures = 0;
+	for (const entry of orphaned) {
+		if (!existsSync$1(entry.dir)) continue;
+		let run;
+		try {
+			run = await withIdleWorkspace(entry.projectRoot, async () => {
+				if (!stillOrphaned(entry)) return false;
+				const browser = await teardownOwnedBrowser(entry.projectRoot, { deleteProfile: true });
+				if (browser.status === "failed" || browser.status === "skipped") throw new Error(`its owned Chrome profile was kept: ${browser.reason}`);
+				emptyWorkspaceDir(entry.dir);
+				return true;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
+			recordGcResult("workspaceDirectory", "failed", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		if (!run.ran) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: run.reasons.join("; ")
+			});
+			continue;
+		}
+		if (!run.value) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: "it can no longer be confirmed orphaned"
+			});
+			continue;
+		}
+		const size = entry.bytes === void 0 ? "" : ` (${sizeText(entry.bytes)})`;
+		console.log(chalk.green(`Removed the orphaned workspace directory ${entry.dir}${size}`));
+		recordGcResult("workspaceDirectory", "done", entry.dir, { bytes: entry.bytes ?? null });
+	}
+	return failures;
+}
+function sizeText(bytes) {
+	return bytes === null ? "size unknown" : formatBytes(bytes);
+}
+//#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 && setting.scopedHomeValue !== void 0) 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$1(current) !== current) current = dirname$1(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) : "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$1(home, "Library", "Developer", "CoreSimulator", "Devices")], ["Xcode DerivedData", join$1(home, "Library", "Developer", "Xcode", "DerivedData")]] : [],
+		["Android emulators", join$1(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$1}`))) 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 { includesWorkspaceOutputs as A, deviceSweepIsScoped as C, unverifiedDeviceCommand as D, findStaleProjectDevices as E, sizeCaches as F, stopOwnedMetroForReset as I, selectCaches as M, trimCaches as N, withAndroidAvdSizes as O, discoverCaches as P, describeUnverifiableDevices as S, findStaleDeviceRecords as T, collectParkedSims as _, REBUILD_COST as a, deleteProjectDevices as b, collectOrphanedWorkspaces as c, isInsideWorkspaces as d, listWorkspaceDirs as f, collectParkedAvds as g, collectDeviceLeases as h, machineNumber as i, planCacheEmptying as j, emptyCaches as k, collectWorkspaceOutputs as l, DEVICE_LIST_TIMEOUT_MS$1 as m, budgetLine as n, WORKSPACE_OUTPUT_DIRS as o, sizeText as p, inspectBudget as r, clearWorkspaceOutputs as s, budgetGate as t, deleteOrphanedWorkspaces as u, deleteParkedAvds as v, findOrphanedDevices as w, describeParkedSims as x, deleteParkedSims as y };