stim 1.9.0 → 1.10.0

package/dist/workspaces-BTUyFfkv.mjs

@@ -0,0 +1,1003 @@
+import { A as directorySize, H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, T as withConfigLock$1, f as getProject, g as loadConfig$1, h as isPathPrefix, i as clearDevice, j as formatBytes, u as getConfigDir, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { i as registeredCaches } from "./cache-manifest-Pubfp8wV.mjs";
+import { M as workspaceName$1, v as workspaceLastUsed } from "./metro-BWLOJ_Wr.mjs";
+import { u as plural } from "./command-output-D5z2_bcF.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-CbEaIk7b.mjs";
+import { A as ownedAvdDirectory, C as isStimOwnedAvdName, K as isStimOwnedSim, T as listAvds } from "./android-787HhP5w.mjs";
+import { _ as dropParked, b as readParked, d as teardownOwnedAvd, f as teardownOwnedIosSim, m as teardownParkedIosSim, p as teardownParkedAvd } from "./ownership-DZjdx8Gq.mjs";
+import { d as listIosDeviceTypes, g as parseRuntimeVersion, l as listAllIosSims } from "./ios-B2Fpqvlb.mjs";
+import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-CjUluqIX.mjs";
+import { existsSync, lstatSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
+import { isJsonObject, readJsonFile } from "@stim-cli/core/state";
+import { homedir, tmpdir } from "os";
+import chalk from "chalk";
+//#region src/cache/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;
+	}
+	const uid = process.getuid?.();
+	const files = [];
+	let bytes = 0;
+	for (const n of names) try {
+		const st = statSync(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(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(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 {
+			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(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(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 reportFailures(cache, failed) {
+	if (!failed) return;
+	console.log(chalk.red(`${cache.name}: ${failed} entr${failed === 1 ? "y" : "ies"} in ${cache.dir} could not be removed`));
+	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}`));
+			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;
+			trimmed.push(c);
+			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}`));
+			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 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 = 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 = [], isOwned = isStimCreated }) {
+	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 && !isOwned(device)) unverified.push(device);
+		else if (!ref) orphaned.push(device);
+		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 && !isOwned(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 isStimCreated(device) {
+	return device.kind === "ios" ? isStimOwnedSim({
+		udid: device.id,
+		name: device.name
+	}) : isStimOwnedAvdName(device.id);
+}
+function unverifiedDeviceCommand(device) {
+	return device.kind === "ios" ? `xcrun simctl delete ${device.id}` : `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.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$1);
+		for (const { slot, platforms } of projectDeviceSlots(proj)) {
+			const ios = 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,
+				...slot === "default" ? {} : { slot },
+				idleDays
+			});
+			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,
+			includeUnavailable: true
+		});
+	} catch {
+		return describeParkedSims(records, [], [], { simsChecked: false });
+	}
+	try {
+		deviceTypes = (deps.listIosDeviceTypes ?? listIosDeviceTypes)();
+	} catch {}
+	return describeParkedSims(records, sims, deviceTypes);
+}
+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,
+			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, 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}`;
+		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 (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)`));
+	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(root).toSorted();
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const name of names) {
+		const dir = join(root, name);
+		try {
+			if (!statSync(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(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(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}`));
+			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(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)}`));
+			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}`));
+			continue;
+		}
+		cleared += entry.bytes ?? 0;
+		clearedRoots.push(root);
+		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(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(entry.dir)) continue;
+		let run;
+		try {
+			run = await withIdleWorkspace(entry.projectRoot, () => {
+				if (!stillOrphaned(entry)) return false;
+				emptyWorkspaceDir(entry.dir);
+				return true;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
+			continue;
+		}
+		if (!run.ran) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
+			continue;
+		}
+		if (!run.value) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: 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}`));
+	}
+	return failures;
+}
+function sizeText(bytes) {
+	return bytes === null ? "size unknown" : formatBytes(bytes);
+}
+//#endregion
+export { discoverCaches as A, unverifiedDeviceCommand as C, planCacheEmptying as D, includesWorkspaceOutputs as E, selectCaches as O, findStaleProjectDevices as S, emptyCaches as T, describeParkedSims as _, collectWorkspaceOutputs as a, findOrphanedDevices as b, listWorkspaceDirs as c, collectDeviceLeases as d, collectParkedAvds as f, deleteProjectDevices as g, deleteParkedSims as h, collectOrphanedWorkspaces as i, sizeCaches as j, trimCaches as k, sizeText as l, deleteParkedAvds as m, WORKSPACE_OUTPUT_DIRS as n, deleteOrphanedWorkspaces as o, collectParkedSims as p, clearWorkspaceOutputs as r, isInsideWorkspaces as s, REBUILD_COST as t, DEVICE_LIST_TIMEOUT_MS as u, describeUnverifiableDevices as v, withAndroidAvdSizes as w, findStaleDeviceRecords as x, deviceSweepIsScoped as y };