stim 1.0.0 → 1.2.0

package/dist/gc-B7KkDinF.mjs

@@ -0,0 +1,1665 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { A as directorySize, M as isOnMountedVolume, N as listMountedVolumes, P as volumeRootFor, g as loadConfig, i as clearDevice, j as formatBytes, u as getConfigDir, v as removeProject } from "./config-CMtIaTk9.mjs";
+import { i as registeredCaches } from "./cache-manifest-Cu4_Znw9.mjs";
+import { T as workspaceDir, k as workspaceStateFile } from "./state-CZ-ER-8d.mjs";
+import { g as repoRoot, s as gitCommonDir } from "./worktree-C79xx_kM.mjs";
+import { a as findProjectRoot, i as detectIsExpo } from "./project-BBTVABUz.mjs";
+import { S as readParked, _ as teardownParkedIosSim, b as dropParked, d as resolveEasCliBin, g as teardownParkedAvd, h as teardownOwnedIosSim, m as teardownOwnedAvd, v as POOL_SETTING_REMEDY, x as parkedMaxSetting } from "./remote-cache-DDmJ1Roq.mjs";
+import { A as resolveSettings, N as settingShapeErrors, a as SETTING_SHAPE_REMEDY } from "./settings-DwU1_U_q.mjs";
+import { m as shortUdid, o as formatLongDuration, u as plural } from "./command-output-8wHMEde0.mjs";
+import { d as listIosDeviceTypes, g as parseRuntimeVersion, u as listAllIosSims } from "./ios-D1h1Di39.mjs";
+import { r as listBuildLocks } from "./build-lock-BsVoLDaq.mjs";
+import { d as readClaimSet, o as clearFreeClaimSet } from "./ownership-claim-7zRxxTfZ.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired, u as removeExpiredLease } from "./device-lease-Dpik41RY.mjs";
+import { n as listBuildSlots } from "./build-slots-D0b6sJyo.mjs";
+import { S as listOrphanedAvdDirectories, T as ownedAvdDirectory, b as listAvds } from "./android-K63_0UfF.mjs";
+import { C as verifyStoppedSession, S as stopSessionArgs, _ as inspectSessionForTeardown, d as withEasProjectLock, f as easMachineStateRoot, g as getSessionArgs, h as findOrphanedOwnedSessions, m as removeEasSessionClaim, p as readEasSessionLedger, u as withRemoteSessionLock, v as isDefinitiveMissingSessionError, x as parseSessionListPage, y as listOwnedSessionsArgs } from "./device-remote-E81KAdXf.mjs";
+import { n as reclaimProject, t as describeDereferenced } from "./reclaim-C5Jmuahx.mjs";
+import { InvalidArgumentError } from "commander";
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
+import chalk from "chalk";
+//#region src/caches.ts
+function xcodeDerivedDataRoot() {
+	return join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+}
+function compilationCache() {
+	const dir = join(xcodeDerivedDataRoot(), "CompilationCache.noindex");
+	if (!existsSync(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(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(root)) return null;
+	let names;
+	try {
+		names = readdirSync(root).filter((n) => n.startsWith("metro-file-map-"));
+	} catch {
+		return null;
+	}
+	if (!names.length) return null;
+	let bytes = 0;
+	for (const n of names) try {
+		bytes += statSync(join(root, n)).size;
+	} catch {}
+	return {
+		name: "Metro file maps",
+		dir: root,
+		files: names.map((n) => join(root, n)),
+		bytes,
+		prune: "entries",
+		note: `${names.length} file(s), one per project root Metro has served`
+	};
+}
+function declaredCaches(paths) {
+	return (paths || []).map((p) => resolve(p.startsWith("~") ? join(homedir(), p.slice(1)) : p)).filter((p) => existsSync(p)).map((dir) => ({
+		name: "declared",
+		dir,
+		prune: "entries",
+		note: "from the `caches` setting"
+	}));
+}
+function projectSettings(cwd) {
+	const root = findProjectRoot(cwd);
+	if (!root) return {};
+	return resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root)
+	});
+}
+function declaredCachePaths(cwd = process.cwd()) {
+	const declared = projectSettings(cwd).caches;
+	return Array.isArray(declared) ? declared : [];
+}
+function projectSettingShapeErrors(cwd = process.cwd()) {
+	return settingShapeErrors(projectSettings(cwd));
+}
+function discoverCaches({ declared = [] } = {}) {
+	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(),
+		...declaredCaches(declared)
+	].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(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;
+	for (const entry of entries) {
+		let used;
+		let size;
+		try {
+			const st = statSync(entry);
+			used = Math.max(st.atimeMs, st.mtimeMs);
+			size = st.isDirectory() ? directorySize(entry) : st.size;
+		} catch {
+			continue;
+		}
+		if (used >= cutoff) continue;
+		try {
+			rmSync(entry, {
+				recursive: true,
+				force: true
+			});
+			removed++;
+			bytes += size;
+		} catch {}
+	}
+	return {
+		removed,
+		bytes,
+		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(parent);
+			} catch {
+				continue;
+			}
+			for (const name of names) next.push(join(parent, name));
+		}
+		level = next;
+	}
+	return level;
+}
+//#endregion
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return resolve(p);
+	}
+}
+//#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(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";
+function selectCaches(caches, name) {
+	if (!name) return caches;
+	const wanted = name.trim().toLowerCase();
+	if (wanted === EVERY_CACHE) return caches;
+	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$1
+	});
+	let names;
+	try {
+		names = readdirSync(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(join(cache.dir, name), {
+			recursive: true,
+			force: true
+		});
+		removed++;
+	} catch {
+		failed++;
+	}
+	return {
+		removed,
+		bytes: failed ? 0 : cache.bytes ?? 0,
+		failed,
+		skipped: null
+	};
+}
+function trimCaches(caches, olderThan) {
+	let cacheBytes = 0;
+	for (const c of caches) {
+		if (c.machineGlobal) {
+			console.log(chalk.yellow(`Left ${c.name} alone: ${c.machineGlobal}`));
+			continue;
+		}
+		const r = pruneCache(c, { olderThanDays: olderThan });
+		if (r.skipped) console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
+		else if (r.removed) {
+			cacheBytes += r.bytes;
+			console.log(chalk.green(`Trimmed ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
+		} else console.log(chalk.dim(`${c.name}: nothing older than ${olderThan}d`));
+	}
+	if (cacheBytes) console.log(chalk.dim(`Trimmed ${formatBytes(cacheBytes)} of shared cache. The next build that wanted those entries pays to rebuild them.`));
+}
+function emptyCaches(caches) {
+	let cacheBytes = 0;
+	for (const c of caches) {
+		if (!c.willEmpty) {
+			console.log(chalk.yellow(`Left ${c.name} alone: ${c.emptySkipped}`));
+			continue;
+		}
+		const r = emptyCache(c);
+		if (r.skipped) console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
+		else if (r.removed) {
+			cacheBytes += r.bytes;
+			console.log(chalk.green(`Emptied ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
+		} else console.log(chalk.dim(`${c.name}: already empty`));
+		if (r.failed) console.log(chalk.red(`  ${r.failed} entr${r.failed === 1 ? "y" : "ies"} in ${c.dir} could not be removed`));
+	}
+	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 = 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;
+		const ios = proj?.platforms?.ios;
+		if (ios?.deviceUdid) referenced.set(ios.deviceUdid, {
+			path,
+			mounted
+		});
+		const android = proj?.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 = [];
+	for (const sim of sims) {
+		if (!sim?.name?.startsWith("stim-")) continue;
+		const ref = referenced.get(sim.udid);
+		if (!ref) orphaned.push({
+			kind: "ios",
+			id: sim.udid,
+			name: sim.name
+		});
+		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);
+		if (!ref) orphaned.push({
+			kind: "android",
+			id: avdName,
+			name: avdName
+		});
+		else kept.push({
+			kind: "android",
+			id: avdName,
+			name: avdName,
+			reason: describeKept(ref)
+		});
+	}
+	return {
+		orphaned,
+		kept
+	};
+}
+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.name]));
+	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);
+		const ios = proj?.platforms?.ios;
+		if (ios?.owned && ios.deviceUdid && liveSims.has(ios.deviceUdid)) stale.push({
+			kind: "ios",
+			id: ios.deviceUdid,
+			name: liveSims.get(ios.deviceUdid),
+			project: path,
+			idleDays
+		});
+		const android = proj?.platforms?.android;
+		if (android?.owned && android.avdName && liveAvds.has(android.avdName)) stale.push({
+			kind: "android",
+			id: android.avdName,
+			name: android.avdName,
+			project: path,
+			idleDays
+		});
+	}
+	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;
+		const ios = proj?.platforms?.ios;
+		if (simsChecked && ios?.deviceUdid && !liveSims.has(ios.deviceUdid)) stale.push({
+			kind: "ios",
+			id: ios.deviceUdid,
+			project: path,
+			owned: Boolean(ios.owned)
+		});
+		const android = proj?.platforms?.android;
+		if (avdsChecked && android?.avdName && !liveAvds.has(android.avdName)) stale.push({
+			kind: "android",
+			id: android.avdName,
+			project: path,
+			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 collectParkedSims(deps) {
+	const records = readParked("ios");
+	if (records.length === 0) return [];
+	let sims;
+	let deviceTypes = [];
+	try {
+		sims = (deps.listAllIosSims ?? listAllIosSims)({
+			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+			includeUnavailable: true
+		});
+	} catch {
+		return describeParkedSims(records, [], [], { simsChecked: false });
+	}
+	try {
+		deviceTypes = (deps.listIosDeviceTypes ?? listIosDeviceTypes)();
+	} catch {}
+	return describeParkedSims(records, sims, deviceTypes);
+}
+function collectParkedAvds(deps) {
+	const records = readParked("android");
+	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,
+			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.`));
+			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}`));
+		} else if (result.status === "torn-down") console.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
+		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.`));
+			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}`));
+				} else console.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
+				continue;
+			}
+			emptied++;
+			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}`));
+		}
+	}
+	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(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) {
+		const r = d.kind === "ios" ? teardownOwnedIosSim(d.id, {
+			del: true,
+			label: d.name
+		}) : teardownOwnedAvd(d.name, {
+			del: true,
+			..."project" in d ? { owner: { projectPath: d.project } } : {},
+			..."orphanedDirectory" in d ? { orphanedDirectory: d.orphanedDirectory } : {}
+		});
+		const what = d.kind === "ios" ? `ios sim ${d.name} (${d.id})` : `android avd ${d.name}`;
+		if (r.status === "torn-down") console.log(chalk.green(`Deleted ${what}`));
+		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`));
+		else {
+			deleteFailures++;
+			console.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
+		}
+		return r.status;
+	}
+	for (const d of orphanedDevices) reap(d);
+	for (const d of staleDevices) {
+		const status = reap(d);
+		if (status === "torn-down" || status === "missing") {
+			clearDevice(d.project, d.kind);
+			console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
+		}
+	}
+	for (const r of staleDeviceRecords) {
+		clearDevice(r.project, r.kind);
+		console.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
+	}
+	return deleteFailures;
+}
+//#endregion
+//#region src/commands/gc/eas-sessions.ts
+const EAS_OPERATION_TIMEOUT_MS = 3e4;
+const EAS_COLLECTION_TIMEOUT_MS = 6e4;
+const EAS_MAX_LIST_PAGES = 100;
+const EAS_LOCK_WAIT_MS = 0;
+const EAS_LOCK_SNAPSHOT_RETRIES = 3;
+const PROXY_CREDENTIAL_ENV = ["AGENT_DEVICE_DAEMON_BASE_URL", "AGENT_DEVICE_DAEMON_AUTH_TOKEN"];
+function describeError(error) {
+	const candidate = error;
+	if (typeof candidate?.stderr === "string" && candidate.stderr.trim()) return candidate.stderr.trim();
+	if (typeof candidate?.message === "string" && candidate.message.trim()) return candidate.message.trim();
+	return String(error);
+}
+function readRecordedRemoteSessionIds(roots) {
+	const ids = /* @__PURE__ */ new Set();
+	const notices = [];
+	let safe = true;
+	for (const root of new Set(roots)) {
+		try {
+			if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
+			readdirSync(root);
+		} catch (error) {
+			safe = false;
+			notices.push(`${root} is not available as a readable workspace directory: ${describeError(error)}`);
+			continue;
+		}
+		const path = workspaceStateFile(root);
+		if (!existsSync(path)) continue;
+		let state;
+		try {
+			state = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (error) {
+			safe = false;
+			notices.push(`${path} could not be read as valid JSON: ${describeError(error)}`);
+			continue;
+		}
+		if (!state || typeof state !== "object" || Array.isArray(state)) {
+			safe = false;
+			notices.push(`${path} does not contain a valid workspace state object.`);
+			continue;
+		}
+		const remote = state.remoteDevice;
+		if (remote === void 0) continue;
+		if (!remote || typeof remote !== "object" || Array.isArray(remote)) {
+			safe = false;
+			notices.push(`${path} has a malformed remote session record.`);
+			continue;
+		}
+		const id = remote.sessionId;
+		if (typeof id !== "string" || id.length === 0) {
+			safe = false;
+			notices.push(`${path} has a remote session record with no valid session id.`);
+			continue;
+		}
+		ids.add(id);
+	}
+	return {
+		ids: [...ids],
+		notices,
+		safe
+	};
+}
+function claimStateAbsence(claim) {
+	const stateDir = dirname(claim.stateFile);
+	let entries;
+	try {
+		if (!statSync(stateDir).isDirectory()) throw new Error("path is not a directory");
+		entries = readdirSync(stateDir);
+	} catch (error) {
+		return {
+			absent: false,
+			notice: `${stateDir} is not available for EAS ownership verification: ${describeError(error)}`
+		};
+	}
+	if (!entries.includes(basename(claim.stateFile))) return {
+		absent: true,
+		notice: null
+	};
+	let state;
+	try {
+		state = JSON.parse(readFileSync(claim.stateFile, "utf-8"));
+	} catch (error) {
+		return {
+			absent: false,
+			notice: `${claim.stateFile} could not be read as valid JSON: ${describeError(error)}`
+		};
+	}
+	if (!state || typeof state !== "object" || Array.isArray(state)) return {
+		absent: false,
+		notice: `${claim.stateFile} does not contain a valid workspace state object.`
+	};
+	const remote = state.remoteDevice;
+	if (remote === void 0) return {
+		absent: true,
+		notice: null
+	};
+	if (!remote || typeof remote !== "object" || Array.isArray(remote)) return {
+		absent: false,
+		notice: `${claim.stateFile} has a malformed remote session record.`
+	};
+	const sessionId = remote.sessionId;
+	if (typeof sessionId !== "string" || !sessionId) return {
+		absent: false,
+		notice: `${claim.stateFile} has a remote session record with no valid session id.`
+	};
+	return {
+		absent: sessionId !== claim.sessionId,
+		notice: null
+	};
+}
+function collectEasSessionSweep(config, deps) {
+	const projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
+	const empty = (notices = []) => ({
+		projectScope: projectRoot,
+		orphaned: [],
+		notices,
+		deletionSafe: notices.length === 0
+	});
+	if (!projectRoot || !(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return empty();
+	if (deps.easSweepBlockedNotice) return empty([deps.easSweepBlockedNotice]);
+	const eas = (deps.resolveEasCliBin ?? resolveEasCliBin)(projectRoot);
+	if (!eas) return empty(["EAS session sweep skipped: eas-cli is not available for the current Expo project."]);
+	const recorded = readRecordedRemoteSessionIds([...Object.keys(config?.projects ?? {}), projectRoot]);
+	const ledgerRoot = deps.easLedgerRoot ?? easMachineStateRoot();
+	const ledger = readEasSessionLedger(ledgerRoot);
+	const run = deps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
+	const sessions = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	const now = deps.easNow ?? Date.now;
+	const collectionTimeoutMs = deps.easCollectionTimeoutMs ?? EAS_COLLECTION_TIMEOUT_MS;
+	const maxPages = deps.easMaxPages ?? EAS_MAX_LIST_PAGES;
+	const deadline = now() + collectionTimeoutMs;
+	let pageCount = 0;
+	let after = null;
+	while (true) {
+		if (pageCount >= maxPages) return empty([...recorded.notices, `EAS session list exceeded the maximum page limit of ${maxPages} for ${projectRoot}.`]);
+		const remainingMs = deadline - now();
+		if (remainingMs <= 0) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
+		let stdout;
+		try {
+			stdout = run(eas.file, listOwnedSessionsArgs(after), {
+				cwd: projectRoot,
+				timeoutMs: Math.min(EAS_OPERATION_TIMEOUT_MS, remainingMs),
+				omitEnv: PROXY_CREDENTIAL_ENV
+			});
+		} catch (error) {
+			return empty([...recorded.notices, `EAS session list failed for ${projectRoot}: ${describeError(error)}`]);
+		}
+		pageCount++;
+		if (now() > deadline) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
+		const parsed = parseSessionListPage(stdout);
+		if (!parsed.ok) return empty([...recorded.notices, parsed.reason]);
+		sessions.push(...parsed.page.sessions);
+		if (!parsed.page.hasNextPage) break;
+		const cursor = parsed.page.endCursor?.trim();
+		if (!cursor) return empty([...recorded.notices, "EAS session list has a next page but returned no pagination cursor."]);
+		if (seenCursors.has(cursor)) return empty([...recorded.notices, `EAS session list repeated pagination cursor ${cursor}.`]);
+		seenCursors.add(cursor);
+		after = cursor;
+	}
+	const lockedRoots = deps.easLockedRoots;
+	if (lockedRoots) {
+		if (easLockRoots(projectRoot, loadConfig()).some((root) => !lockedRoots.includes(root))) return empty([...recorded.notices, "EAS session sweep skipped: registered workspace roots changed after remote-session locks were acquired."]);
+	}
+	const compared = findOrphanedOwnedSessions({
+		sessions,
+		recordedSessionIds: recorded.ids,
+		projectScope: projectRoot
+	});
+	const notices = [...recorded.notices, ...compared.notices];
+	if (ledger.notice) notices.push(ledger.notice);
+	const orphaned = [];
+	if (ledger.safe && recorded.safe) for (const session of compared.orphaned) {
+		const claim = ledger.claims.get(session.id);
+		if (!claim || claim.name !== session.name || claim.platform !== session.platform) {
+			notices.push(`EAS session ${session.id} (${session.name}) is unclaimed or its fixed ownership record does not match; it was not selected for deletion.`);
+			continue;
+		}
+		const state = claimStateAbsence(claim);
+		if (state.notice) {
+			notices.push(state.notice);
+			continue;
+		}
+		if (state.absent) orphaned.push(session);
+	}
+	return {
+		projectScope: projectRoot,
+		orphaned,
+		notices,
+		deletionSafe: recorded.safe && ledger.safe
+	};
+}
+function easLockRoots(projectRoot, config) {
+	return [...new Set([...Object.keys(config?.projects ?? {}), projectRoot].map(canonicalPath))].toSorted();
+}
+function unavailableLockRootNotice(roots) {
+	for (const root of roots) try {
+		if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
+		readdirSync(root);
+	} catch (error) {
+		return `EAS session sweep skipped: ${root} is not available for remote-session lock inspection: ${describeError(error)}`;
+	}
+	return null;
+}
+function malformedRemoteSessionLockNotice(roots) {
+	for (const root of roots) {
+		const lockPath = join(workspaceDir(root), "remote-session.lock");
+		if (!existsSync(lockPath)) continue;
+		if (readClaimSet(lockPath).unresolved.length === 0) continue;
+		return `EAS session sweep skipped: the remote-session lock at ${lockPath} has a malformed owner record.`;
+	}
+	return null;
+}
+async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
+	const withLock = deps.withRemoteSessionLock ?? withRemoteSessionLock;
+	const waitMs = deps.easLockWaitMs ?? EAS_LOCK_WAIT_MS;
+	const maxSnapshots = deps.easLockSnapshotRetries ?? EAS_LOCK_SNAPSHOT_RETRIES;
+	for (let attempt = 0; attempt < maxSnapshots; attempt++) {
+		const roots = easLockRoots(projectRoot, loadConfig());
+		const unavailable = unavailableLockRootNotice(roots);
+		if (unavailable) return fn({
+			...deps,
+			easSweepBlockedNotice: unavailable
+		});
+		const malformed = malformedRemoteSessionLockNotice(roots);
+		if (malformed) return fn({
+			...deps,
+			easSweepBlockedNotice: malformed
+		});
+		let expanded = false;
+		let coreStarted = false;
+		const acquire = (index) => index === roots.length ? (async () => {
+			if (easLockRoots(projectRoot, loadConfig()).some((root) => !roots.includes(root))) {
+				expanded = true;
+				return null;
+			}
+			coreStarted = true;
+			return fn({
+				...deps,
+				easSweepBlockedNotice: void 0,
+				easLockedRoots: roots
+			});
+		})() : withLock(roots[index], () => acquire(index + 1), { waitMs });
+		try {
+			const result = await acquire(0);
+			if (!expanded) return result;
+		} catch (error) {
+			if (coreStarted) throw error;
+			return fn({
+				...deps,
+				easSweepBlockedNotice: `EAS session sweep skipped: remote-session lock acquisition failed: ${describeError(error)}`
+			});
+		}
+	}
+	return fn({
+		...deps,
+		easSweepBlockedNotice: `EAS session sweep skipped: registered workspace roots kept changing during remote-session lock acquisition.`
+	});
+}
+async function deleteEasSessions(easSessionSweep, deps) {
+	let deleteFailures = 0;
+	if (easSessionSweep.orphaned.length && easSessionSweep.deletionSafe && easSessionSweep.projectScope) {
+		const projectScope = easSessionSweep.projectScope;
+		const withProjectLock = deps.withEasProjectLock ?? withEasProjectLock;
+		let finalSweepStarted = false;
+		try {
+			await withProjectLock(projectScope, () => {
+				finalSweepStarted = true;
+				return withRemoteSessionGcLocks(projectScope, deps, async (lockedDeps) => {
+					if (lockedDeps.easSweepBlockedNotice) {
+						deleteFailures += easSessionSweep.orphaned.length;
+						console.log(chalk.red(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`));
+						return;
+					}
+					const coordinatedDeps = lockedDeps;
+					const currentConfig = loadConfig();
+					const currentRoots = easLockRoots(projectScope, currentConfig);
+					const registryExpanded = coordinatedDeps.easLockedRoots && currentRoots.some((root) => !coordinatedDeps.easLockedRoots.includes(root));
+					const currentRecords = registryExpanded ? null : readRecordedRemoteSessionIds([...Object.keys(currentConfig?.projects ?? {}), projectScope]);
+					const ledgerRoot = coordinatedDeps.easLedgerRoot ?? easMachineStateRoot();
+					const ledger = readEasSessionLedger(ledgerRoot);
+					const removeClaim = coordinatedDeps.removeEasSessionClaim ?? removeEasSessionClaim;
+					const reconcileClaim = (sessionId) => {
+						let detail = "the claim store did not remove it";
+						try {
+							if (removeClaim(sessionId, ledgerRoot)) return;
+						} catch (error) {
+							detail = describeError(error);
+						}
+						deleteFailures++;
+						console.log(chalk.red(`EAS session ${sessionId} is resolved, but its ownership claim could not be removed: ${detail}. The claim was retained for reconciliation.`));
+					};
+					if (registryExpanded) {
+						deleteFailures += easSessionSweep.orphaned.length;
+						console.log(chalk.red("EAS session deletion refused: registered workspace roots changed after classification."));
+					} else if (!currentRecords?.safe || !ledger.safe) {
+						deleteFailures += easSessionSweep.orphaned.length;
+						for (const notice of [...currentRecords?.notices ?? [], ...ledger.notice ? [ledger.notice] : []]) console.log(chalk.red(`EAS session deletion refused: ${notice}`));
+					} else {
+						const recorded = new Set(currentRecords.ids);
+						const eas = (coordinatedDeps.resolveEasCliBin ?? resolveEasCliBin)(projectScope);
+						const run = coordinatedDeps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
+						for (const session of easSessionSweep.orphaned) {
+							if (recorded.has(session.id)) {
+								console.log(chalk.dim(`EAS session ${session.id} has a workspace record and was left running.`));
+								continue;
+							}
+							const claim = ledger.claims.get(session.id);
+							const claimState = claim ? claimStateAbsence(claim) : null;
+							if (!claim || claim.name !== session.name || claim.platform !== session.platform || !claimState?.absent || claimState.notice) {
+								deleteFailures++;
+								console.log(chalk.red(`Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`));
+								continue;
+							}
+							if (!eas) {
+								deleteFailures++;
+								console.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
+								continue;
+							}
+							const options = {
+								cwd: session.projectScope,
+								timeoutMs: EAS_OPERATION_TIMEOUT_MS,
+								omitEnv: PROXY_CREDENTIAL_ENV
+							};
+							let live;
+							try {
+								live = run(eas.file, getSessionArgs(session.id), options);
+							} catch (error) {
+								if (isDefinitiveMissingSessionError(error, session.id)) {
+									console.log(chalk.dim(`EAS session ${session.id} is already gone.`));
+									reconcileClaim(session.id);
+								} else {
+									deleteFailures++;
+									console.log(chalk.red(`Could not verify EAS session ${session.id}: ${describeError(error)}`));
+								}
+								continue;
+							}
+							const inspection = inspectSessionForTeardown(live, session.id);
+							if (inspection.action === "already-stopped") {
+								console.log(chalk.dim(`EAS session ${session.id} is already stopped (${inspection.status}).`));
+								reconcileClaim(session.id);
+								continue;
+							}
+							if (inspection.action === "refused") {
+								deleteFailures++;
+								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${inspection.reason}`));
+								continue;
+							}
+							let stopped;
+							try {
+								stopped = run(eas.file, stopSessionArgs(session.id), options);
+							} catch (error) {
+								deleteFailures++;
+								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
+								continue;
+							}
+							const verified = verifyStoppedSession(stopped, session.id);
+							if (!verified.ok) {
+								deleteFailures++;
+								console.log(chalk.red(`Could not verify EAS session ${session.id} stopped: ${verified.reason}`));
+								continue;
+							}
+							console.log(chalk.green(`Stopped EAS session ${session.id} (${session.name})`));
+							reconcileClaim(session.id);
+						}
+					}
+				});
+			}, {
+				waitMs: 0,
+				ownerPurpose: "EAS orphan deletion",
+				machineRoot: deps.easLedgerRoot
+			});
+		} catch (error) {
+			deleteFailures += easSessionSweep.orphaned.length;
+			const phase = finalSweepStarted ? "failed" : "lock acquisition failed";
+			console.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
+		}
+	}
+	return deleteFailures;
+}
+//#endregion
+//#region src/commands/gc/report.ts
+function shortKey(key) {
+	const text = String(key ?? "");
+	return text.length > 6 ? `${text.slice(0, 6)}..` : text;
+}
+function parkedAge(parkedAt, now) {
+	const at = Date.parse(parkedAt);
+	if (!Number.isFinite(at)) return "parked at an unknown time";
+	return `parked ${formatLongDuration(Math.max(0, now - at))} ago`;
+}
+function formatParkedSimReport(parkedSims, now) {
+	if (parkedSims.length === 0) return [];
+	const known = parkedSims.filter((sim) => sim.bytes !== null);
+	const total = known.reduce((sum, sim) => sum + (sim.bytes ?? 0), 0);
+	const size = known.length === parkedSims.length ? `, ${formatBytes(total)}` : "";
+	const lines = [`Parked simulators (${parkedSims.length}${size}):`];
+	for (const sim of parkedSims) {
+		const model = [sim.model, sim.runtime].filter(Boolean).join(" ");
+		const age = parkedAge(sim.parkedAt, now);
+		const bytes = sim.bytes === null ? "" : ` ${formatBytes(sim.bytes)}`;
+		const gone = sim.listed === false ? " - not on this machine" : sim.listed === null ? " - listing unavailable; kept" : "";
+		lines.push(`  ios ${sim.name} (${shortUdid(sim.udid)})${model ? ` ${model}` : ""} ${age}${bytes}${gone}`);
+	}
+	lines.push("              --delete attempts verified deletions and keeps failures.");
+	return lines;
+}
+function formatParkedAvdReport(parkedAvds, now) {
+	if (!parkedAvds.length) return [];
+	const lines = [];
+	lines.push(`Parked emulators (${parkedAvds.length}):`);
+	for (const avd of parkedAvds) {
+		const listed = avd.listed === false ? " - not on this machine" : avd.listed === null ? " - listing unavailable; kept" : "";
+		lines.push(`  android ${avd.name} ${avd.systemImage} ${parkedAge(avd.parkedAt, now)}${avd.bytes === null ? "" : ` ${formatBytes(avd.bytes)}`}${listed}`);
+	}
+	lines.push("              --delete attempts verified deletions and keeps failures.");
+	return lines;
+}
+function projectEntryLines(header, paths) {
+	return paths.length ? [header, ...paths.map((path) => `  ${path}`)] : [];
+}
+function unresolvedLockLines(locks, slots) {
+	const entries = [...locks.unresolved ?? [], ...slots.unresolved ?? []];
+	if (entries.length === 0) return [];
+	return [
+		`Build locks and slots Stim cannot resolve (${entries.length}) - NOT touched, because a dead holder and a live one cannot be told apart:`,
+		...entries.map((entry) => `  ${entry.path}`),
+		"              remove one yourself once you know nothing is building with it"
+	];
+}
+function formatGcReport({ skipped = [], deadProjects = [], invalidProjects = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, buildSlots = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, deviceLeases = {
+	expired: [],
+	kept: []
+}, deviceSweepNotices = [], easSessionSweep = {
+	projectScope: null,
+	orphaned: [],
+	notices: [],
+	deletionSafe: true
+}, caches = [], cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
+	const lines = [];
+	const staleLocks = buildLocks?.stale ?? [];
+	const liveLocks = buildLocks?.live ?? [];
+	const staleSlots = buildSlots?.stale ?? [];
+	const expiredLeases = deviceLeases?.expired ?? [];
+	if (cacheScope) lines.push(`Cache scope: "${cacheScope}". Devices, project entries and locks were not inspected.`);
+	else if (deadProjects.length === 0 && invalidProjects.length === 0 && parkedSims.length === 0 && parkedAvds.length === 0 && orphanedDevices.length === 0 && staleDevices.length === 0 && staleDeviceRecords.length === 0 && staleLocks.length === 0 && staleSlots.length === 0 && expiredLeases.length === 0 && easSessionSweep.orphaned.length === 0) {
+		const reasons = [];
+		if (skipped.length > 0) reasons.push(`${skipped.length} entr${skipped.length === 1 ? "y" : "ies"} could not be checked`);
+		if (deviceSweepNotices.length > 0) reasons.push("device sweep incomplete");
+		if (easSessionSweep.notices.length > 0) reasons.push("EAS session sweep incomplete");
+		if (reasons.length > 0) lines.push(`Nothing to reclaim (${reasons.join("; ")}; see below).`);
+		else lines.push("Nothing to reclaim.");
+	}
+	lines.push(...projectEntryLines(`Dead project entries (${deadProjects.length}):`, deadProjects));
+	lines.push(...projectEntryLines(`Invalid project entries (${invalidProjects.length}) - the key is not an absolute path:`, invalidProjects));
+	lines.push(...formatParkedSimReport(parkedSims, now));
+	lines.push(...formatParkedAvdReport(parkedAvds, now));
+	if (orphanedDevices.length) {
+		lines.push(`Orphaned devices (${orphanedDevices.length}):`);
+		for (const d of orphanedDevices) lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
+	}
+	if (staleDevices.length) {
+		lines.push(`Stale owned devices (${staleDevices.length}) - project untouched for ${olderThan ?? "?"}d or more:`);
+		for (const d of staleDevices) {
+			lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
+			lines.push(`              ${d.project} (idle ${d.idleDays}d)`);
+		}
+	}
+	if (staleDeviceRecords.length) {
+		lines.push(`Stale device records (${staleDeviceRecords.length}) - the device is gone, the project is not:`);
+		for (const r of staleDeviceRecords) {
+			lines.push(`  ${r.kind} ${r.id} is not on this machine`);
+			lines.push(`              recorded by ${r.project}`);
+		}
+		lines.push("              --delete clears the RECORD only; there is no device left to touch.");
+	}
+	if (easSessionSweep.orphaned.length) {
+		lines.push(`Orphaned EAS sessions (${easSessionSweep.orphaned.length}) - current EAS project only:`);
+		for (const session of easSessionSweep.orphaned) {
+			const details = [session.platform, session.status].filter(Boolean).join(", ");
+			lines.push(`  ${session.name} (${session.id})${details ? ` [${details}]` : ""}`);
+			lines.push(`              project scope: ${session.projectScope}`);
+			lines.push(`              remedy: eas simulator:stop --id ${session.id}`);
+		}
+	}
+	if (staleLocks.length) {
+		lines.push(`Stale build locks (${staleLocks.length}) - the process that was building is gone:`);
+		for (const lock of staleLocks) {
+			lines.push(`  ${lock.platform} ${shortKey(lock.key)} (pid ${lock.pid ?? "?"} is not running)`);
+			lines.push(`              started by ${lock.projectRoot || "an unrecorded workspace"}`);
+		}
+	}
+	if (staleSlots.length) {
+		lines.push(`Stale build slots (${staleSlots.length}) - the process that was building is gone:`);
+		for (const slot of staleSlots) {
+			lines.push(`  slot ${slot.index ?? "?"} (pid ${slot.pid ?? "?"} is not running)`);
+			lines.push(`              held by ${slot.projectRoot || "an unrecorded workspace"}`);
+		}
+	}
+	lines.push(...unresolvedLockLines(buildLocks, buildSlots));
+	if (liveLocks.length) {
+		lines.push(`Builds in progress (${liveLocks.length}) - NOT touched, by anything:`);
+		for (const lock of liveLocks) {
+			lines.push(`  ${lock.platform} ${shortKey(lock.key)} (pid ${lock.pid})`);
+			lines.push(`              building in ${lock.projectRoot || "an unrecorded workspace"}`);
+		}
+	}
+	lines.push(...leaseGarbageLines(deviceLeases));
+	if (deviceSweepNotices.length) {
+		lines.push(`Device sweep notices (${deviceSweepNotices.length}):`);
+		for (const notice of deviceSweepNotices) lines.push(`  ${notice}`);
+	}
+	if (easSessionSweep.notices.length) {
+		lines.push(`EAS session sweep notices (${easSessionSweep.notices.length}):`);
+		for (const notice of easSessionSweep.notices) lines.push(`  ${notice}`);
+	}
+	if (skipped.length) {
+		lines.push(`Skipped (${skipped.length}) - not classified as dead:`);
+		for (const entry of skipped) lines.push(`  ${entry.dir}: ${entry.reason}`);
+	}
+	if (caches.length) {
+		const total = caches.reduce((n, c) => n + (c.bytes ?? 0), 0);
+		lines.push(`Shared build caches (${caches.length}) - alive, not garbage:`);
+		for (const c of caches) {
+			const tag = c.source ? ` (${c.source})` : "";
+			lines.push(`  ${formatBytes(c.bytes ?? 0).padStart(10)}  ${c.name}${tag}`);
+			lines.push(`              ${c.dir}`);
+			if (c.note) lines.push(`              ${c.note}`);
+			if (c.willEmpty) lines.push("              would be EMPTIED");
+			else if (c.emptySkipped) lines.push(`              would be left alone: ${c.emptySkipped}`);
+		}
+		lines.push(`  total: ${formatBytes(total)}`);
+		const doomed = caches.filter((c) => c.willEmpty);
+		if (doomed.length) {
+			const doomedBytes = doomed.reduce((n, c) => n + (c.bytes ?? 0), 0);
+			lines.push(`  would empty ${doomed.length} of these (${formatBytes(doomedBytes)})`);
+		}
+	}
+	return lines;
+}
+function leaseGarbageLines({ expired, kept }) {
+	const lines = [];
+	if (expired.length) {
+		lines.push(`Expired device leases (${expired.length}) - the device is already free:`);
+		for (const entry of expired) {
+			const name = entry.lease?.deviceName ? ` (${entry.lease.deviceName})` : "";
+			lines.push(`  ${entry.platform} ${entry.id ?? entry.name}${name}`);
+			lines.push(`              held by ${entry.lease?.holder ?? "an unrecorded workspace"} until ${entry.lease?.expiresAt}`);
+		}
+		lines.push("              --delete removes the FILE only; an expired lease already holds nothing.");
+	}
+	if (kept.length) {
+		lines.push(`Device lease files kept (${kept.length}) - reported, never deleted:`);
+		for (const entry of kept) lines.push(`  ${entry.name}: ${entry.reason}`);
+	}
+	return lines;
+}
+function deviceSizeSuffix(device) {
+	return device.kind === "android" && device.bytes !== void 0 ? ` - ${formatBytes(device.bytes)} on disk` : "";
+}
+//#endregion
+//#region src/commands/gc.ts
+function removeInvalidProjectEntries(invalidProjects) {
+	for (const path of invalidProjects) {
+		removeProject(path);
+		console.log(chalk.green(`Removed the invalid registry entry ${path}`));
+	}
+}
+function projectLastTouched(path) {
+	try {
+		return statSync(path).mtimeMs;
+	} catch {
+		return NaN;
+	}
+}
+async function collectGcReport({ olderThan = null, cache = null, now = Date.now(), lastTouched = projectLastTouched } = {}, deps = {}) {
+	const scope = typeof cache === "string" && cache.trim() ? cache : null;
+	const all = scope !== null && olderThan === null;
+	const caches = planCacheEmptying(sizeCaches(selectCaches(discoverCaches({ declared: declaredCachePaths() }), scope)), all);
+	if (scope) return {
+		skipped: [],
+		deadProjects: [],
+		invalidProjects: [],
+		orphanedDevices: [],
+		staleDevices: [],
+		staleDeviceRecords: [],
+		buildLocks: {
+			stale: [],
+			live: [],
+			unresolved: []
+		},
+		buildSlots: {
+			stale: [],
+			live: [],
+			unresolved: []
+		},
+		deviceLeases: {
+			expired: [],
+			kept: []
+		},
+		deviceSweepNotices: [],
+		easSessionSweep: {
+			projectScope: null,
+			orphaned: [],
+			notices: [],
+			deletionSafe: true
+		},
+		parkedSims: [],
+		parkedAvds: [],
+		caches,
+		cacheScope: scope,
+		olderThan,
+		all
+	};
+	const mountedVolumes = listMountedVolumes();
+	const cfg = loadConfig();
+	let easSessionSweep = deps.precollectedEasSessionSweep;
+	if (!easSessionSweep) try {
+		easSessionSweep = collectEasSessionSweep(cfg, deps);
+	} catch (error) {
+		easSessionSweep = {
+			projectScope: null,
+			orphaned: [],
+			notices: [`EAS session sweep failed: ${describeError(error)}`],
+			deletionSafe: false
+		};
+	}
+	const parkedSims = collectParkedSims(deps);
+	const parkedAvds = collectParkedAvds(deps);
+	const deadProjects = [];
+	const invalidProjects = [];
+	const skipped = [];
+	for (const [path, project] of Object.entries(cfg?.projects || {})) {
+		if (!isAbsolute(path)) {
+			const claimed = describeDereferenced(project);
+			if (claimed.length) skipped.push({
+				dir: path,
+				reason: `not an absolute path, so this record is invalid; kept because it still claims ${claimed.join(" and ")}; gc removes it once that claim is gone, or drop the entry from the config file by hand`
+			});
+			else invalidProjects.push(path);
+			continue;
+		}
+		if (existsSync(path)) continue;
+		if (!isOnMountedVolume(path, mountedVolumes)) {
+			const volume = volumeRootFor(path);
+			skipped.push({
+				dir: path,
+				reason: `volume ${volume} is not mounted`
+			});
+		} else deadProjects.push(path);
+	}
+	const deviceSweepNotices = [];
+	let orphanedDevices = [];
+	let staleDevices = [];
+	let staleDeviceRecords = [];
+	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped() ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
+	if (unsweepableReason) {
+		let simNames = [];
+		let avdNames = [];
+		try {
+			simNames = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }).map((s) => s.name);
+		} catch {}
+		try {
+			avdNames = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+		} catch {}
+		deviceSweepNotices.push(...describeUnverifiableDevices(simNames, avdNames, { reason: unsweepableReason }));
+	} else {
+		let sims = [];
+		let simsChecked = true;
+		try {
+			sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+		} catch {
+			simsChecked = false;
+			deviceSweepNotices.push(`ios device sweep skipped: simulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
+		}
+		let avds = [];
+		let avdsChecked = true;
+		try {
+			avds = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+		} catch {
+			avdsChecked = false;
+			deviceSweepNotices.push(`android device sweep skipped: emulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
+		}
+		let orphanedAvdDirectories = [];
+		if (avdsChecked) try {
+			orphanedAvdDirectories = listOrphanedAvdDirectories();
+		} catch (error) {
+			avdsChecked = false;
+			deviceSweepNotices.push(`android data sweep skipped: ${error.message}`);
+		}
+		avds = [.../* @__PURE__ */ new Set([...avds, ...orphanedAvdDirectories.map((entry) => entry.name)])];
+		const isMounted = (path) => isOnMountedVolume(path, mountedVolumes);
+		orphanedDevices = withAndroidAvdSizes(findOrphanedDevices({
+			sims,
+			avds,
+			config: cfg,
+			isMounted,
+			deadProjects
+		}).orphaned.flatMap((device) => {
+			const directories = device.kind === "android" ? orphanedAvdDirectories.filter((entry) => entry.name === device.name) : [];
+			return directories.length ? directories.map((orphanedDirectory) => Object.assign({}, device, { orphanedDirectory })) : [device];
+		}), {
+			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
+			size: deps.directorySize ?? directorySize
+		});
+		staleDeviceRecords = findStaleDeviceRecords({
+			config: cfg,
+			sims,
+			avds,
+			deadProjects,
+			simsChecked,
+			avdsChecked
+		});
+		if (olderThan !== null) staleDevices = withAndroidAvdSizes(findStaleProjectDevices({
+			config: cfg,
+			sims,
+			avds,
+			olderThanDays: olderThan,
+			now,
+			lastTouched,
+			deadProjects
+		}), {
+			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
+			size: deps.directorySize ?? directorySize
+		});
+	}
+	const locks = listBuildLocks();
+	const slots = listBuildSlots();
+	const deviceLeases = collectDeviceLeases(now);
+	return {
+		skipped,
+		deadProjects,
+		invalidProjects,
+		parkedSims,
+		parkedAvds,
+		orphanedDevices,
+		staleDevices,
+		staleDeviceRecords,
+		buildLocks: {
+			stale: locks.filter((l) => !l.alive && !l.unresolved),
+			live: locks.filter((l) => l.alive),
+			unresolved: locks.filter((l) => l.unresolved)
+		},
+		buildSlots: {
+			stale: slots.filter((s) => !s.alive && !s.unresolved),
+			live: slots.filter((s) => s.alive),
+			unresolved: slots.filter((s) => s.unresolved)
+		},
+		deviceLeases,
+		deviceSweepNotices,
+		easSessionSweep,
+		caches,
+		cacheScope: null,
+		olderThan,
+		all
+	};
+}
+async function runGc(opts = {}, deps = {}) {
+	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
+	if (poolError) console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
+	const shapeErrors = (deps.settingShapeErrors ?? projectSettingShapeErrors)();
+	if (shapeErrors.length) {
+		for (const message of shapeErrors) console.error(chalk.red(message));
+		console.error(chalk.dim(SETTING_SHAPE_REMEDY));
+		process.exitCode = 1;
+		return;
+	}
+	if (opts.cache) return runGcCore(opts, {
+		...deps,
+		precollectedEasSessionSweep: {
+			projectScope: null,
+			orphaned: [],
+			notices: [],
+			deletionSafe: true
+		}
+	});
+	let projectRoot = null;
+	try {
+		projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
+		if (!projectRoot) return runGcCore(opts, {
+			...deps,
+			precollectedEasSessionSweep: {
+				projectScope: null,
+				orphaned: [],
+				notices: ["EAS session sweep skipped: no current project was available before EAS project lock acquisition."],
+				deletionSafe: false
+			}
+		});
+		if (!(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return runGcCore(opts, {
+			...deps,
+			precollectedEasSessionSweep: {
+				projectScope: projectRoot,
+				orphaned: [],
+				notices: [],
+				deletionSafe: true
+			}
+		});
+	} catch (error) {
+		return runGcCore(opts, {
+			...deps,
+			precollectedEasSessionSweep: {
+				projectScope: projectRoot,
+				orphaned: [],
+				notices: [`EAS session sweep skipped: project classification failed before EAS project lock acquisition: ${describeError(error)}`],
+				deletionSafe: false
+			}
+		});
+	}
+	const withProjectLock = deps.withEasProjectLock ?? withEasProjectLock;
+	let sweepStarted = false;
+	let easSessionSweep;
+	try {
+		easSessionSweep = await withProjectLock(projectRoot, () => {
+			sweepStarted = true;
+			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => Promise.resolve(collectEasSessionSweep(loadConfig(), coordinatedDeps)));
+		}, {
+			waitMs: 0,
+			ownerPurpose: "EAS orphan sweep",
+			machineRoot: deps.easLedgerRoot
+		});
+	} catch (error) {
+		easSessionSweep = {
+			projectScope: projectRoot,
+			orphaned: [],
+			notices: [`EAS session sweep skipped: ${sweepStarted ? "EAS collection failed" : "EAS project lock acquisition failed"}: ${describeError(error)}`],
+			deletionSafe: false
+		};
+	}
+	return runGcCore(opts, {
+		...deps,
+		precollectedEasSessionSweep: easSessionSweep
+	});
+}
+async function runGcCore(opts, deps) {
+	const olderThan = typeof opts.olderThan === "number" ? opts.olderThan : null;
+	const cache = typeof opts.cache === "string" && opts.cache.trim() ? opts.cache : null;
+	const report = await collectGcReport({
+		olderThan,
+		cache
+	}, deps);
+	if (cache && report.caches.length === 0) {
+		const names = [...new Set(discoverCaches({ declared: declaredCachePaths() }).map((c) => c.name))];
+		console.log(chalk.yellow(`No shared cache carries "${cache}" in its name or directory.`));
+		if (names.length) console.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
+		return;
+	}
+	const all = report.all;
+	for (const line of formatGcReport(report)) console.log(line);
+	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches } = report;
+	const actionable = deadProjects.length + invalidProjects.length > 0 || report.parkedSims.length > 0 || report.parkedAvds.length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0;
+	if (!opts.delete) {
+		if (all) console.log(chalk.dim("\nDry run. Re-run with --delete to empty the caches above."));
+		else if (actionable) console.log(chalk.dim("\nDry run. Re-run with --delete to reclaim."));
+		else if (caches.length) console.log(chalk.dim("\nPass --delete --cache all to empty the caches above, or --delete --older-than <days> to trim them."));
+		return;
+	}
+	let deleteFailures = deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
+	removeInvalidProjectEntries(invalidProjects);
+	for (const path of deadProjects) {
+		const result = await reclaimProject(path);
+		if (result.keptEntry) console.log(chalk.yellow(`Could not fully prune ${path}; its registry entry was kept.`));
+		else console.log(chalk.green(`Pruned ${path}`));
+		for (const dir of result.removedWorkspaceDirs) console.log(chalk.dim(`  removed workspace output ${dir}`));
+		for (const dir of result.failedWorkspaceDirs) {
+			console.log(chalk.red(`  could not remove workspace output ${dir}`));
+			deleteFailures += 1;
+		}
+		if (result.killedPid) console.log(chalk.dim(`  killed orphaned Metro pid ${result.killedPid}`));
+		if (result.stoppedSession) console.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
+		if (result.stoppedTunnel) console.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
+		for (const s of result.skippedDevices) console.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
+	}
+	deleteFailures += deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
+	for (const lock of buildLocks.stale) {
+		const cleared = clearFreeClaimSet({
+			root: lock.path,
+			label: `${lock.platform} build`
+		});
+		if (cleared.status === "held") continue;
+		if (cleared.status === "refused") {
+			console.log(chalk.yellow(`Left the build lock at ${lock.path} alone: ${cleared.reason}`));
+			continue;
+		}
+		if (cleared.status === "failed") {
+			deleteFailures++;
+			console.log(chalk.red(`Failed to clear the build lock at ${lock.path}: ${cleared.reason}`));
+			continue;
+		}
+		console.log(chalk.green(`Cleared the ${lock.platform} build lock left by pid ${lock.pid ?? "?"} (${lock.projectRoot || "unrecorded workspace"})`));
+	}
+	for (const slot of buildSlots.stale) {
+		const cleared = clearFreeClaimSet({
+			root: slot.path,
+			label: "build slot"
+		});
+		if (cleared.status === "held") continue;
+		if (cleared.status === "refused") {
+			console.log(chalk.yellow(`Left the build slot at ${slot.path} alone: ${cleared.reason}`));
+			continue;
+		}
+		if (cleared.status === "failed") {
+			deleteFailures++;
+			console.log(chalk.red(`Failed to clear the build slot at ${slot.path}: ${cleared.reason}`));
+			continue;
+		}
+		console.log(chalk.green(`Cleared build slot ${slot.index ?? "?"} left by pid ${slot.pid ?? "?"} (${slot.projectRoot || "unrecorded workspace"})`));
+	}
+	for (const entry of deviceLeases.expired) try {
+		if (removeExpiredLease(entry)) console.log(chalk.green(`Cleared the expired ${entry.platform} device lease on ${entry.id ?? entry.name} (held by ${entry.lease?.holder ?? "an unrecorded workspace"})`));
+		else console.log(chalk.dim(`${entry.name} is no longer an expired lease; left alone.`));
+	} catch (err) {
+		deleteFailures++;
+		console.log(chalk.red(`Failed to clear the device lease at ${entry.path}: ${err?.message || err}`));
+	}
+	deleteFailures += await deleteEasSessions(easSessionSweep, deps);
+	if (deleteFailures) console.log(chalk.red(`\n${deleteFailures} entr${deleteFailures === 1 ? "y" : "ies"} could not be deleted; see above.`));
+	if (all) {
+		emptyCaches(caches);
+		return;
+	}
+	if (olderThan === null) {
+		if (caches.length) console.log(chalk.dim("Shared caches left alone: pass --cache all to empty them, or --older-than <days> to trim them."));
+		return;
+	}
+	trimCaches(caches, olderThan);
+}
+function gcCommand(program) {
+	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, and the shared build caches. Reports by default; pass --delete to act.").option("--delete", "actually prune the reported entries and reap the reported devices").option("--older-than <days>", "also reap owned devices whose project has been untouched this long, and trim shared cache entries nothing has used in that time", (v) => {
+		const n = parseInt(v, 10);
+		if (!Number.isFinite(n) || String(n) !== String(v).trim()) throw new InvalidArgumentError("must be a whole number of days, e.g. --older-than 30");
+		return n;
+	}).option("--cache <name>", "act on the shared caches whose name or directory contains <name>, or every cache with --cache all, a reserved name that never selects a single cache. With --delete they are emptied whole, which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Only those caches are reported; devices and project entries are not inspected. Caches outside the config dir are refused while STIM_HOME is set.", (v) => {
+		if (!v.trim()) throw new InvalidArgumentError("must name a cache, e.g. --cache \"compilation cache\"");
+		return v;
+	}).action(async (opts) => {
+		await runGc(opts);
+	});
+}
+//#endregion
+export { collectGcReport, gcCommand as default, deleteParkedSims, describeParkedSims, describeUnverifiableDevices, findOrphanedDevices, findStaleDeviceRecords, findStaleProjectDevices, formatGcReport, runGc, selectCaches };