stim 1.26.0 → 1.28.0

package/dist/{workspaces-g2lhdBXF.mjs → workspaces-CmOcceDN.mjs}

@@ -1,31 +1,64 @@
-import { D as ownership_claim_exports, S as process_identity_exports, c as throwIfCancelled, d as workspaceProcessLockError, f as workspaceProcessLockPath, l as WorkspaceProcessCleanupError, m as declareSpawnsOn, o as cancellableSleep, t as getExecutor, u as withWorkspaceProcessLock, v as stopDeclaringSpawnsOn } from "./exec-VFRpu1iA.mjs";
-import { A as workspaceName$1, E as workspaceDir, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, u as workspaceLastUsed, w as workspaceAgentDeviceDir } from "./workspace-state-pUg3_RRA.mjs";
-import { F as isOnMountedVolume, G as projectDeviceSlots, H as deviceSlotPlatforms, I as listMountedVolumes, L as measuredDirectorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix, j as acquireAvdClaim, p as getProject } from "./config-BktkY_zC.mjs";
+import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, c as throwIfCancelled, d as workspaceProcessLockError, f as workspaceProcessLockPath, l as WorkspaceProcessCleanupError, m as declareSpawnsOn, o as cancellableSleep, t as getExecutor, u as withWorkspaceProcessLock, v as stopDeclaringSpawnsOn } from "./exec-aULwtNly.mjs";
+import { A as workspaceName$1, E as workspaceDir, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, u as workspaceLastUsed, w as workspaceAgentDeviceDir } from "./workspace-state-kIZrdlSg.mjs";
+import { D as withConfigLock$1, F as isOnMountedVolume, G as projectDeviceSlots, H as deviceSlotPlatforms, I as listMountedVolumes, L as measuredDirectorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix$1, j as acquireAvdClaim, p as getProject } from "./config-Cn94Jc0g.mjs";
 import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-BF5AR2dL.mjs";
-import { t as runOperationFile } from "./operation-exec-CUZifp6Z.mjs";
-import { Pt as repoRootAsync, dt as resolveTailscaleBinary } from "./settings-CosW5X-S.mjs";
-import { a as macosRuntimeClaim, n as macosDir } from "./state-C4OdpOTF.mjs";
-import { Ct as forgetCreatedDeviceAsync, H as ownedAvdMatchesConfiguration, K as ownedAvdSystemImage, L as listOrphanedAvdDirectories, S as deleteAvd, St as forgetCreatedDevice, Tt as recordCreatedDevice, V as ownedAvdDirectory, _t as parkSim, bt as removeParkedAfter, g as avdPathExists, ht as eraseParkedAfter, it as shutdownAndroidEmulator, j as listAdbDevicesAsync, lt as wipeAvdUserData, nt as resolveOwnedAvdSerialAsync, p as assertOwnedAvdStoppedAsync, st as waitForAndroidEmulatorShutdown, ut as isStimOwnedAvd, v as avdStorageRoots, wt as readCreatedDevices$1, yt as readParked } from "./android-DTAcRwBC.mjs";
-import { c as pidExists, f as signalProcessTree, p as signalProcessTreeAsync } from "./metro-CjC10t6E.mjs";
-import { _ as chromeProcessStateAsync, c as webClaimRoot, i as clearWebRecord, o as readWebRecord, p as webProfileDir, t as CDP_PORT_LABEL, u as webFacts, v as liveProfileHolder, y as removeSingletonFiles } from "./state-C1i2nMOP.mjs";
+import { a as formatElapsed, d as quotedPath$1, l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-C8R1KIvi.mjs";
+import { c as gitQuiet, l as gitQuietAsync, t as runOperationFile } from "./operation-exec-Dp4FuIGR.mjs";
+import { Pt as lockReason, Vt as repoRootAsync, Xt as worktreeLockAsync, Yt as worktreeLock, pt as resolveTailscaleBinary } from "./settings-CY5JZlNN.mjs";
+import { a as macosRuntimeClaim, n as macosDir } from "./state-BXC1Lfxw.mjs";
+import { Ct as forgetCreatedDeviceAsync, G as ownedAvdSerialResolverAsync, H as ownedAvdMatchesConfiguration, K as ownedAvdSystemImage, L as listOrphanedAvdDirectories, S as deleteAvd, St as forgetCreatedDevice, Tt as recordCreatedDevice, V as ownedAvdDirectory, W as ownedAvdSerialResolver, _t as parkSim, bt as removeParkedAfter, g as avdPathExists, ht as eraseParkedAfter, it as shutdownAndroidEmulator, j as listAdbDevicesAsync, lt as wipeAvdUserData, nt as resolveOwnedAvdSerialAsync, p as assertOwnedAvdStoppedAsync, st as waitForAndroidEmulatorShutdown, ut as isStimOwnedAvd, v as avdStorageRoots, wt as readCreatedDevices$1, yt as readParked } from "./android-CsPs-7Mg.mjs";
+import { c as pidExists, f as signalProcessTree, p as signalProcessTreeAsync } from "./metro-BnhXV2Mj.mjs";
+import { _ as chromeProcessStateAsync, c as webClaimRoot, i as clearWebRecord, o as readWebRecord, p as webProfileDir, t as CDP_PORT_LABEL, u as webFacts, v as liveProfileHolder, y as removeSingletonFiles } from "./state-B2QJbDwz.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { N as listBuildLocks, d as readAgentDeviceRecords, t as agentDeviceDaemon } from "./activity-Lnb_EoRY.mjs";
-import { C as renameIosSim, D as resolveOwnedIosSim, c as eraseIosSim, f as listAllIosSimsAsync, k as shutdownIosSim, o as deleteIosSim, p as listIosDeviceTypesAsync, s as deleteParkedIosSim, v as parkedSimName, y as parseRuntimeVersion } from "./ios-WxpDJ5T1.mjs";
-import { r as releaseBrowserPort } from "./named-ports-BG0j1X4g.mjs";
+import { N as listBuildLocks, d as readAgentDeviceRecords, i as createActivityReaderAsync, r as createActivityReader, s as idleForMs, t as agentDeviceDaemon } from "./activity-DRMg4_mD.mjs";
+import { C as renameIosSim, D as resolveOwnedIosSim, c as eraseIosSim, f as listAllIosSimsAsync, k as shutdownIosSim, o as deleteIosSim, p as listIosDeviceTypesAsync, s as deleteParkedIosSim, v as parkedSimName, y as parseRuntimeVersion } from "./ios-B1DYuOjh.mjs";
+import { r as releaseBrowserPort } from "./named-ports-Phoi2POD.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { ambientContext, ambientEnv, ambientWrite } from "@stim-cli/core";
-import { buildSlotsDir, hostedNativeRecords, isJsonObject, macosAppState, parseHostedNativePlacement, readJsonFile, readMacosRecord, requireAutomaticMachine, tryAcquireBuildSlotClaim, unreadableHostedNative } from "@stim-cli/core/state";
+import { ambientContext, ambientEnv, ambientWrite, withDirLock, workspaceName } from "@stim-cli/core";
+import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_LEDGER_CAP, BUILD_PHASES, LAST_BUILD_KEYS, STATS_VERSION, buildLedgerFile, buildLedgerLock, buildSlotsDir, decodeStats, hostedAppAttempt, hostedNativeRecords, isJsonObject, lastNativeUseFrom, loadPerCore, macosAppState, parseHostedNativePlacement, parseMissReason, readJsonFile, readMacosRecord, readRunEstimates, readStats as readStats$1, requireAutomaticMachine, statsFile, statsProjectKey as statsProjectKey$1, trace, trimCapacityRefusals, trimCapacityWaits, trimSamples, tryAcquireBuildSlotClaim, unreadableHostedNative, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1 } from "path";
 import { request } from "node:https";
 import chalk from "chalk";
 import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
 import { lstat, readFile, readdir, rm, stat, unlink } from "node:fs/promises";
 import { resolve4 } from "node:dns/promises";
+//#region src/commands/gc/limited.ts
+const isCleanupFailure = (error) => error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error;
+async function eachLimited(items, limit, run) {
+	const queue = items[Symbol.iterator]();
+	let failed = false;
+	const worker = async () => {
+		for (const item of queue) {
+			if (failed) return;
+			try {
+				await run(item);
+			} catch (error) {
+				failed = true;
+				throw error;
+			}
+		}
+	};
+	const errors = (await Promise.allSettled(Array.from({ length: Math.min(limit, items.length) }, worker))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+	if (errors.length) throw errors.find(isCleanupFailure) ?? errors[0];
+}
+function readConcurrency(operation) {
+	return operationState(operation).declaring.size ? 1 : 6;
+}
+function sizeConcurrency(operation) {
+	return operationState(operation).declaring.size ? 1 : 4;
+}
+async function mapLimited(items, limit, run) {
+	const done = [];
+	await eachLimited([...items.entries()], limit, async ([index, item]) => {
+		done.push([index, await run(item)]);
+	});
+	return done.toSorted(([a], [b]) => a - b).map(([, result]) => result);
+}
+//#endregion
 //#region src/commands/gc/results.ts
 function createGcResults(observe) {
 	const results = [];
@@ -71,7 +104,8 @@ function toRecord(holder) {
 		index: typeof details.index === "number" ? details.index : null,
 		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
 		startedAt: holder.startedAt || null,
-		logFile: typeof details.logFile === "string" ? details.logFile : null
+		logFile: typeof details.logFile === "string" ? details.logFile : null,
+		client: details.offloaded === true && typeof details.client === "string" ? details.client : null
 	};
 }
 function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
@@ -97,7 +131,8 @@ function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
 			index: got.index,
 			projectRoot: root,
 			startedAt: got.claim.startedAt,
-			logFile
+			logFile,
+			client: null
 		},
 		claim: got.claim
 	};
@@ -191,12 +226,37 @@ function listBuildSlots() {
 			projectRoot: info?.projectRoot ?? null,
 			startedAt: info?.startedAt ?? null,
 			logFile: info?.logFile ?? null,
+			client: info?.client ?? null,
 			alive: survey.live.length > 0,
 			unresolved: survey.unresolved.length > 0
 		});
 	}
 	return slots;
 }
+/** The `concurrency.maxBuilds` slots a new build could take, `0` to `max - 1`, and who holds each busy one. */
+function buildSlotUsage(max, slots = listBuildSlots()) {
+	const holders = slots.flatMap(({ index, alive, unresolved, projectRoot, client, startedAt }) => {
+		if (index === null || index >= max) return [];
+		if (alive) return [{
+			slot: index,
+			workspace: projectRoot,
+			client,
+			since: startedAt
+		}];
+		return unresolved ? [{
+			slot: index,
+			workspace: null,
+			client: null,
+			since: null,
+			unresolved: true
+		}] : [];
+	}).toSorted((a, b) => a.slot - b.slot);
+	return {
+		max,
+		inUse: holders.length,
+		holders
+	};
+}
 //#endregion
 //#region src/devices/report-only-usage.ts
 function canonical$1(path) {
@@ -349,6 +409,10 @@ function deviceClaims(device) {
 		workspace: record.workspace && canonical(record.workspace)
 	}));
 }
+var AgentDeviceRefusal = class extends Error {
+	reason;
+	stateDir;
+};
 function explainFailure(error) {
 	const stdout = error?.stdout;
 	let failure;
@@ -358,13 +422,17 @@ function explainFailure(error) {
 		failure = void 0;
 	}
 	if (typeof failure?.message !== "string" || !failure.message) return error;
-	const reason = typeof failure.details?.reason === "string" ? ` (${failure.details.reason})` : "";
-	return /* @__PURE__ */ new Error(`agent-device refused: ${failure.message}${reason}`);
+	const reason = typeof failure.details?.reason === "string" ? failure.details.reason : void 0;
+	const stateDir = typeof failure.details?.stateDir === "string" ? failure.details.stateDir : void 0;
+	const refusal = new AgentDeviceRefusal(`agent-device refused: ${failure.message}${reason ? ` (${reason})` : ""}`);
+	refusal.reason = reason;
+	refusal.stateDir = stateDir;
+	return refusal;
 }
 function report(message) {
 	ambientWrite("stderr", `${phaseLine("device", message)}\n`);
 }
-async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot, operation) {
+async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot, operation, reportedBusy = /* @__PURE__ */ new Set()) {
 	const exec = getExecutor();
 	try {
 		operation?.signal.throwIfAborted();
@@ -378,6 +446,7 @@ async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot,
 		};
 		const stateDir = root === void 0 ? void 0 : workspaceAgentDeviceDir(root);
 		const stateDirs = [void 0, ...stateDir && !["none", "dead"].includes(agentDeviceDaemon(stateDir)) ? [stateDir] : []];
+		const busy = /* @__PURE__ */ new Set();
 		for (const dir of stateDirs) {
 			const deadline = Date.now() + 15e3;
 			const run = async (args) => {
@@ -431,9 +500,16 @@ async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot,
 			} catch (error) {
 				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 				operation?.signal.throwIfAborted();
-				report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
+				if (error instanceof AgentDeviceRefusal && error.reason === "daemon-busy") busy.add(error.stateDir ?? dir ?? "");
+				else report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
 			}
 		}
+		const unreported = [...busy].filter((dir) => !reportedBusy.has(dir));
+		if (unreported.length > 0) {
+			for (const dir of unreported) reportedBusy.add(dir);
+			const stop = unreported.map((dir) => `agent-device daemon stop${dir ? ` --state-dir ${quotedPath$1(dir)}` : ""}`);
+			report(`agent-device daemon is busy, so Stim did not check it for sessions on ${device.platform === "ios" ? device.id : device.id ?? device.avdName}; any that name the device stay open until the daemon is idle or, if it is yours, stopped with ${stop.join(" and ")}`);
+		}
 	} catch (error) {
 		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 		operation?.signal.throwIfAborted();
@@ -652,6 +728,7 @@ async function parkOwnedIosSim(settled, udid, park, operation) {
 }
 async function teardownOwnedIosSim(udid, { del = false, label, park, workspace, shutdownClock = {}, operation } = {}) {
 	let parkFallback;
+	const reportedBusy = /* @__PURE__ */ new Set();
 	try {
 		const resolved = await resolveOwnedIosSimNow(udid, operation);
 		if (resolved.notOwned) return {
@@ -663,7 +740,7 @@ async function teardownOwnedIosSim(udid, { del = false, label, park, workspace,
 		await closeOwnedDeviceSessions({
 			platform: "ios",
 			id: udid
-		}, async () => Boolean((await resolveOwnedIosSimNow(udid, operation)).sim), workspace, void 0, operation);
+		}, async () => Boolean((await resolveOwnedIosSimNow(udid, operation)).sim), workspace, void 0, operation, reportedBusy);
 		const current = await resolveOwnedIosSimNow(udid, operation);
 		if (current.missing) return { status: "missing" };
 		if (current.notOwned) return {
@@ -721,7 +798,7 @@ async function teardownOwnedIosSim(udid, { del = false, label, park, workspace,
 		if (root && settled.sim) await closeOwnedDeviceSessions({
 			platform: "ios",
 			id: udid
-		}, async () => (await resolveOwnedIosSimNow(udid, operation)).sim?.state === "Shutdown", workspace, root, operation);
+		}, async () => (await resolveOwnedIosSimNow(udid, operation)).sim?.state === "Shutdown", workspace, root, operation, reportedBusy);
 		return {
 			status: "torn-down",
 			label: label ?? sim.name ?? udid
@@ -849,6 +926,7 @@ async function teardownClaimedAvd(avdName, claim, { operation, del = false, wipe
 	signal: operation?.signal
 }) }) {
 	let parkFallback;
+	const reportedBusy = /* @__PURE__ */ new Set();
 	const resolveAvd = async (name) => {
 		operation?.signal.throwIfAborted();
 		const result = await resolve(name);
@@ -890,7 +968,7 @@ async function teardownClaimedAvd(avdName, claim, { operation, del = false, wipe
 				platform: "android",
 				id: serial,
 				avdName
-			}, stillOwned, workspace, void 0, operation);
+			}, stillOwned, workspace, void 0, operation, reportedBusy);
 			if (!await stillOwned()) throw new Error(`Owned AVD ${avdName} changed before shutdown; it was kept.`);
 			await waitForShutdown(avdName, async (timeoutMs) => {
 				if (!operation) (0, ownership_claim_exports.markClaimChildPending)(claim);
@@ -911,7 +989,7 @@ async function teardownClaimedAvd(avdName, claim, { operation, del = false, wipe
 					platform: "android",
 					id: serial,
 					avdName
-				}, stillStopped, workspace, root, operation);
+				}, stillStopped, workspace, root, operation, reportedBusy);
 			}
 		} else {
 			await closeOwnedDeviceSessions({
@@ -1149,6 +1227,1592 @@ async function teardownBrowserHeld(root, { deleteProfile = false, operation } =
 	}
 }
 //#endregion
+//#region src/engine/stats.ts
+const PLACEMENT_MAX_AGE_MS = 6048e5;
+function emptyStats() {
+	return {
+		version: STATS_VERSION,
+		machine: {},
+		projects: {}
+	};
+}
+function updateStats(record, run, now) {
+	const at = new Date(now).toISOString();
+	const durationMs = wholeMs$1(run.durationMs);
+	const phases = {
+		coldBuildMs: wholeMs$1(run.coldBuildMs),
+		podsMs: wholeMs$1(run.podsMs)
+	};
+	const projects = { ...record.projects };
+	const scope = { ...projects[run.projectKey] };
+	const machine = { ...record.machine };
+	const before = scope[run.platform] ?? null;
+	const credit = creditMs(before, run, durationMs);
+	scope[run.platform] = applyRun(before, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	projects[run.projectKey] = scope;
+	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	const history = { ...record.history };
+	if (run.phases && !run.failed && !run.waitedForBuild && !run.offloadedTo) {
+		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
+		const project = { ...history[run.projectKey] };
+		const lists = { ...project[run.platform] };
+		const sample = {
+			at,
+			durationMs,
+			phases: wholePhases(run.phases),
+			...run.deviceSetup === void 0 ? {} : { deviceSetup: run.deviceSetup }
+		};
+		lists[outcome] = trimSamples([...lists[outcome] ?? [], sample]);
+		project[run.platform] = lists;
+		history[run.projectKey] = project;
+	}
+	let placements = record.placements;
+	let buildMachines = record.buildMachines;
+	if (run.placement) {
+		const placement = buildPlacement(run, before, at);
+		placements = trimPlacements([...placements ?? [], placement], now);
+		if (placement.machine && placement.decision !== "here") buildMachines = {
+			...buildMachines,
+			[placement.machine]: applyPlacement(buildMachines?.[placement.machine], placement)
+		};
+	}
+	const capacityRefusals = trimCapacityRefusals(record.capacityRefusals ?? [], now);
+	const capacityWaits = trimCapacityWaits(record.capacityWaits ?? [], now);
+	return {
+		version: STATS_VERSION,
+		machine,
+		projects,
+		...Object.keys(history).length ? { history } : {},
+		...placements?.length ? { placements } : {},
+		...capacityRefusals.length ? { capacityRefusals } : {},
+		...capacityWaits.length ? { capacityWaits } : {},
+		...buildMachines && Object.keys(buildMachines).length ? { buildMachines } : {}
+	};
+}
+function buildPlacement(run, before, at) {
+	const placement = run.placement;
+	const buildMs = wholeMs$1(placement.decision === "offloaded" ? placement.buildMs : run.coldBuildMs);
+	const localEstimateMs = wholeMs$1(before?.lastColdBuildMs);
+	const slotWaitMs = wholeMs$1(placement.slotWaitMs);
+	const deviceSlotWaitMs = wholeMs$1(placement.deviceSlotWaitMs);
+	return {
+		at,
+		project: run.projectKey,
+		platform: run.platform,
+		decision: placement.decision,
+		reason: placement.reason,
+		...placement.machine ? { machine: placement.machine } : {},
+		...buildMs > 0 ? { buildMs } : {},
+		...slotWaitMs > 0 ? { slotWaitMs } : {},
+		...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {},
+		...localEstimateMs > 0 ? { localEstimateMs } : {},
+		...run.failed ? { failed: true } : {}
+	};
+}
+function applyPlacement(totals, placement) {
+	const next = totals ? { ...totals } : {
+		offloaded: 0,
+		offloadedMs: 0,
+		savedMs: 0,
+		fallbacks: 0
+	};
+	if (placement.decision === "fell-back") {
+		next.fallbacks += 1;
+		next.lastFallbackAt = placement.at;
+		return next;
+	}
+	next.offloaded += 1;
+	next.offloadedMs += placement.buildMs ?? 0;
+	if (placement.localEstimateMs && placement.buildMs) next.savedMs += placement.localEstimateMs - placement.buildMs;
+	next.lastOffloadAt = placement.at;
+	return next;
+}
+function trimPlacements(placements, now) {
+	return placements.filter((each) => now - Date.parse(each.at) <= PLACEMENT_MAX_AGE_MS).slice(-100);
+}
+function recordRunStats(run, now) {
+	return withConfigLock$1(() => {
+		const path = statsFile();
+		const loaded = loadForUpdate(path, now);
+		if (loaded.newerVersion !== null) return {
+			recorded: false,
+			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
+		};
+		writeStats(path, updateStats(loaded.record, run, now));
+		return {
+			recorded: true,
+			note: loaded.note
+		};
+	});
+}
+function recordCapacityRefusal(event, now) {
+	try {
+		withConfigLock$1(() => {
+			const path = statsFile();
+			const loaded = loadForUpdate(path, now, false);
+			if (!loaded.record || loaded.newerVersion !== null) return;
+			const capacityRefusals = trimCapacityRefusals([...loaded.record.capacityRefusals ?? [], {
+				...event,
+				at: new Date(now).toISOString(),
+				kind: "device"
+			}], now);
+			writeStats(path, {
+				...loaded.record,
+				capacityRefusals
+			});
+		});
+	} catch {}
+}
+function recordCapacityWait(event, now) {
+	try {
+		withConfigLock$1(() => {
+			const path = statsFile();
+			const loaded = loadForUpdate(path, now, false);
+			if (!loaded.record || loaded.newerVersion !== null) return;
+			const capacityWaits = trimCapacityWaits([...loaded.record.capacityWaits ?? [], {
+				platform: event.platform,
+				max: event.max,
+				workspace: event.workspace,
+				ms: wholeMs$1(event.ms),
+				...event.reclaimed && Number.isInteger(event.reclaimed) && event.reclaimed > 0 ? { reclaimed: event.reclaimed } : {},
+				at: new Date(now).toISOString(),
+				kind: "device-wait"
+			}], now);
+			writeStats(path, {
+				...loaded.record,
+				capacityWaits
+			});
+		});
+	} catch {}
+}
+function createRunRecorder({ platform, write, now, note, phases, deviceSetup }) {
+	let projectKey = null;
+	let cacheKey = null;
+	let coldBuildMs = 0;
+	let podsMs = 0;
+	let placement = null;
+	let deviceSlotWaitMs = 0;
+	let recorded = false;
+	return {
+		setProject(key) {
+			projectKey = key;
+		},
+		setCacheKey(key) {
+			cacheKey = key;
+		},
+		setBuildMs(ms) {
+			coldBuildMs = wholeMs$1(ms);
+		},
+		setPodsMs(ms) {
+			podsMs = wholeMs$1(ms);
+		},
+		addDeviceSlotWaitMs(ms) {
+			deviceSlotWaitMs += wholeMs$1(ms);
+		},
+		deviceSlotWaitMs() {
+			return deviceSlotWaitMs || void 0;
+		},
+		setPlacement(next) {
+			placement = next;
+		},
+		record({ failed, cacheHit = false, waited = null, durationMs, offloadedTo = null }) {
+			if (!projectKey || !cacheKey || recorded) return;
+			recorded = true;
+			const ran = failed ? {} : phases?.() ?? {};
+			try {
+				const outcome = write({
+					platform,
+					projectKey,
+					failed,
+					cacheHit,
+					waitedForBuild: Boolean(waited),
+					durationMs,
+					...offloadedTo ? { offloadedTo } : {},
+					...coldBuildMs > 0 ? { coldBuildMs } : {},
+					...podsMs > 0 ? { podsMs } : {},
+					...Object.keys(ran).length ? { phases: ran } : {},
+					...failed || deviceSetup?.() === void 0 ? {} : { deviceSetup: deviceSetup() },
+					...placement ? { placement: {
+						...placement,
+						...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {}
+					} } : {}
+				}, now());
+				if (outcome?.note) note(outcome.note);
+			} catch (error) {
+				note(`Run statistics could not be recorded: ${error?.message || error}`);
+			}
+		}
+	};
+}
+function loadForUpdate(path, now, recoverCorrupt = true) {
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return {
+			record: emptyStats(),
+			note: null,
+			newerVersion: null
+		};
+	}
+	const parsed = decodeStats(text);
+	if (!parsed.record && parsed.newerVersion === null) {
+		if (!recoverCorrupt) return {
+			record: null,
+			note: null,
+			newerVersion: null
+		};
+		const aside = `${path}.corrupt-${now}`;
+		renameSync(path, aside);
+		return {
+			record: emptyStats(),
+			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
+			newerVersion: null
+		};
+	}
+	if (parsed.newerVersion !== null) return {
+		record: emptyStats(),
+		note: null,
+		newerVersion: parsed.newerVersion
+	};
+	return {
+		record: parsed.record,
+		note: null,
+		newerVersion: null
+	};
+}
+function writeStats(path, record) {
+	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
+	try {
+		renameSync(tmp, path);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function applyRun(bucket, run, { at, durationMs, credit, phases }) {
+	const next = bucket ? { ...bucket } : {
+		runs: 0,
+		failed: 0,
+		hits: 0,
+		misses: 0,
+		coldRuns: 0,
+		coldRunMs: 0,
+		hitRuns: 0,
+		hitRunMs: 0,
+		timeSavedMs: 0,
+		firstRunAt: at,
+		lastRunAt: at
+	};
+	next.runs += 1;
+	next.lastRunAt = at;
+	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
+	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
+	if (run.failed) {
+		next.failed += 1;
+		return next;
+	}
+	if (isHit(run.cacheHit)) {
+		next.hits += 1;
+		if (!run.waitedForBuild) {
+			next.hitRuns += 1;
+			next.hitRunMs += durationMs;
+			next.timeSavedMs += credit;
+		}
+		return next;
+	}
+	next.misses += 1;
+	if (run.offloadedTo) {
+		next.offloadedRuns = (next.offloadedRuns ?? 0) + 1;
+		next.offloadedRunMs = (next.offloadedRunMs ?? 0) + durationMs;
+		next.lastOffloadHost = run.offloadedTo;
+		return next;
+	}
+	next.coldRuns += 1;
+	next.coldRunMs += durationMs;
+	return next;
+}
+function creditMs(bucket, run, durationMs) {
+	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
+	if (!bucket || bucket.coldRuns <= 0) return 0;
+	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
+}
+function isHit(cacheHit) {
+	return cacheHit === "local" || cacheHit === "remote";
+}
+function wholeMs$1(value) {
+	const ms = Number(value);
+	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
+}
+//#endregion
+//#region src/engine/build-detail.ts
+const LINE_MAX = 160;
+const TARGET_GRAPH = /^note: Target dependency graph \((\d+) targets?\)/;
+const XCODE_ACTION = /^([A-Z][A-Za-z]+)\s(.*)\s\(in target '([^']+)' from project '([^']+)'\)$/;
+const XCODE_CONFIGURE = /^(ComputeTargetDependencyGraph|CreateBuildDescription|CreateBuildRequest|Resolve Package Graph|Prepare packages)$/;
+const GRADLE_TASK = /^> Task (:\S+)/;
+/**
+* xcodebuild actions that end a target's work: a clean build touches each product last, and an incremental build
+* that touches nothing still signs framework products last. Targets that end any other way are not counted.
+*/
+const XCODE_TARGET_DONE = /^(Touch|RegisterExecutionPolicyException|CodeSign)$/;
+const GRADLE_CONFIGURE = /^> Configure project /;
+/**
+* SwiftPM prints `[done / total] name` once it plans the build (with U+2009 thin spaces around the slash in Swift 6.4
+* output), `[done/total] Compiling ...` in older toolchains; Swift 6.4 names the target being worked on, and
+* `<product>-product` is the link of a product.
+*/
+const SWIFTPM_PROGRESS = /^\[(\d+)\s*\/\s*(\d+)\](?:\s+(.*))?$/;
+const SWIFTPM_CONFIGURE = /^(Fetching|Fetched|Computing version|Computed|Creating working copy|Working copy of)\b|^\[(Pre-planning|Planning|Using on-disk description)/;
+const XCODE_STEPS = [
+	[/^(CpResource|CopyPNGFile|CopyStringsFile|CompileAssetCatalog\w*|CompileStoryboard|CompileXIB|LinkStoryboards|ProcessInfoPlistFile)$/, "resources"],
+	[/^(Compile\w*|Swift\w*|ScanDependencies|Precompile\w*)$/, "compile"],
+	[/^(Ld|Libtool|CreateUniversalBinary|GenerateDSYMFile)$/, "link"],
+	[/^PhaseScriptExecution$/, "script"],
+	[/^CodeSign$/, "sign"]
+];
+const GRADLE_STEPS = [
+	[/[Dd]ex/, "dex"],
+	[/^(createBundle\w*JsAndAssets|generateCodegen\w*)$/, "script"],
+	[/(Resources?|Assets|Manifest|ResValues|RFile|JavaRes)$/, "resources"],
+	[/^(compile|kapt|ksp|javaPreCompile|buildCMake|configureCMake|externalNativeBuild)/, "compile"],
+	[/^(package|assemble|install|zipalign|validateSigning|merge\w*NativeLibs|strip\w*Symbols)/, "package"]
+];
+function stepOf(name, table) {
+	return table.find(([pattern]) => pattern.test(name))?.[1] ?? null;
+}
+function clip(text) {
+	return text.length > LINE_MAX ? `${text.slice(0, 157)}...` : text;
+}
+function unescape(token) {
+	return token.replace(/\\(.)/g, "$1");
+}
+function baseName(path) {
+	return path.split("/").findLast(Boolean) ?? path;
+}
+/**
+* An xcodebuild action line in short form: the action, the file it works on and its target, as in
+* `CompileC sqlite3.c (sqlite3)`. The file is the last absolute path in the arguments, which xcodebuild prints
+* as the source for compile, copy and plist steps and as the product for link and sign steps; a script phase
+* shows its name instead.
+*/
+function shortXcodeAction(action, args, target) {
+	const tokens = args.match(/(?:\\.|\S)+/g) ?? [];
+	const subject = action === "PhaseScriptExecution" ? unescape(tokens[0] ?? "") : baseName(unescape(tokens.findLast((token) => token.startsWith("/")) ?? ""));
+	return clip(`${action}${subject ? ` ${subject}` : ""} (${target})`);
+}
+function swiftpmStep(text) {
+	return /^Linking\b|-product$/.test(text) ? "link" : "compile";
+}
+/** What one line of xcodebuild, Gradle or SwiftPM output says about the build's progress, or null for any other line. */
+function parseBuildToolLine(msg) {
+	const counted = SWIFTPM_PROGRESS.exec(msg);
+	if (counted) {
+		const text = counted[3]?.trim() ?? "";
+		return {
+			kind: "count",
+			done: Number(counted[1]),
+			total: Number(counted[2]),
+			step: swiftpmStep(text),
+			line: text ? clip(text) : null
+		};
+	}
+	if (SWIFTPM_CONFIGURE.test(msg)) return { kind: "configure" };
+	const graph = TARGET_GRAPH.exec(msg);
+	if (graph) return {
+		kind: "total",
+		unit: "targets",
+		total: Number(graph[1])
+	};
+	if (XCODE_CONFIGURE.test(msg) || GRADLE_CONFIGURE.test(msg)) return { kind: "configure" };
+	const action = XCODE_ACTION.exec(msg);
+	if (action) {
+		const [, name, args, target, project] = action;
+		const step = stepOf(name, XCODE_STEPS);
+		return {
+			kind: "unit",
+			unit: "targets",
+			id: `${project}/${target}`,
+			step,
+			line: step ? shortXcodeAction(name, args, target) : null,
+			finished: XCODE_TARGET_DONE.test(name)
+		};
+	}
+	const task = GRADLE_TASK.exec(msg);
+	if (task) {
+		const path = task[1];
+		return {
+			kind: "unit",
+			unit: "tasks",
+			id: path,
+			step: stepOf(path.slice(path.lastIndexOf(":") + 1), GRADLE_STEPS),
+			line: clip(`> Task ${path}`),
+			finished: false
+		};
+	}
+	return null;
+}
+/**
+* Accumulates a build's tool output into its detail: xcodebuild counts the distinct targets it finished against the
+* total its dependency graph note gives; Gradle counts the task lines it printed and has no total; SwiftPM reports
+* its own `[done / total]` counts, which the parser passes through.
+*/
+function createBuildDetailParser() {
+	let seen = false;
+	let step = null;
+	let unit = null;
+	let total = null;
+	let line = null;
+	let tasks = 0;
+	let counted = null;
+	const targets = /* @__PURE__ */ new Set();
+	return {
+		push(msg) {
+			const parsed = parseBuildToolLine(msg);
+			if (!parsed) return false;
+			seen = true;
+			if (parsed.kind === "total") {
+				unit = "targets";
+				total = parsed.total;
+				return true;
+			}
+			if (parsed.kind === "configure") {
+				step = "configure";
+				return true;
+			}
+			if (parsed.kind === "count") {
+				unit = "steps";
+				counted = {
+					done: parsed.done,
+					total: parsed.total
+				};
+				step = parsed.step;
+				if (parsed.line) line = parsed.line;
+				return true;
+			}
+			unit = parsed.unit;
+			if (parsed.unit === "tasks") tasks += 1;
+			else if (parsed.finished) targets.add(parsed.id);
+			if (parsed.step) step = parsed.step;
+			if (parsed.line) line = parsed.line;
+			return true;
+		},
+		detail(updatedAt) {
+			if (!seen) return null;
+			if (unit === "steps" && counted) return {
+				step,
+				unit,
+				done: Math.min(counted.done, counted.total),
+				total: counted.total,
+				line,
+				updatedAt
+			};
+			const done = unit === "tasks" ? tasks : unit === "targets" ? targets.size : null;
+			return {
+				step,
+				unit,
+				done: done !== null && total !== null ? Math.min(done, total) : done,
+				total: unit === "tasks" ? null : total,
+				line,
+				updatedAt
+			};
+		}
+	};
+}
+//#endregion
+//#region src/stim-version.ts
+const STIM_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+//#endregion
+//#region src/engine/build-ledger.ts
+const LOCK_WAIT_MS = 2e3;
+const GIT_TIMEOUT_MS = 2e3;
+function text(value) {
+	return typeof value === "string" && value !== "" ? value : null;
+}
+function wholeMs(value) {
+	const ms = Number(value);
+	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
+}
+function wholePhaseMs(phases) {
+	const out = {};
+	for (const [name, ms] of Object.entries(phases ?? {})) if (wholeMs(ms) > 0) out[name] = wholeMs(ms);
+	return out;
+}
+/** The remedy a thrown error carries, when it carries one. */
+function errorRemedy(error) {
+	const remedy = typeof error === "object" && error !== null && "remedy" in error ? error.remedy : void 0;
+	return typeof remedy === "string" && remedy !== "" ? remedy : void 0;
+}
+function buildLedgerRecord(run) {
+	const { record, extras, outcome } = run;
+	const platform = record.platform === "ios" || record.platform === "android" ? record.platform : "macos";
+	const configuration = text(record.configuration);
+	const durationMs = wholeMs(record.durationMs);
+	const startedAt = Date.parse(String(record.startedAt));
+	const fallback = text(record.offloadFallback);
+	const ranHere = fallback !== null || record.builtOn === "here";
+	const machine = text(record.offloadedTo) ?? (ranHere ? null : run.offload?.host) ?? null;
+	const placement = machine ? {
+		where: "offloaded",
+		machine
+	} : fallback ? {
+		where: "local",
+		fellBack: true,
+		reason: fallback
+	} : { where: "local" };
+	const hit = record.cacheHit === "local" || record.cacheHit === "remote" ? record.cacheHit : null;
+	const missReason = text(record.missReason);
+	const cache = {
+		result: record.cacheSkipped === true ? "bypassed" : hit ? "hit" : "miss",
+		...hit && record.cacheSkipped !== true ? { source: hit } : {},
+		key: text(record.cacheKey),
+		fingerprint: text(record.fingerprint),
+		...missReason && !hit ? { missReason } : {}
+	};
+	const offloadPhases = wholePhaseMs(run.offload?.phaseMs);
+	const scheme = text(extras.scheme);
+	const device = text(extras.device?.name);
+	const runtime = text(extras.device?.runtime);
+	const failure = outcome === "succeeded" ? void 0 : {
+		code: text(record.errorCode),
+		message: text(extras.message),
+		remedy: text(extras.remedy),
+		phase: run.phase
+	};
+	const bootStartedAt = run.boot ? Date.parse(run.boot.startedAt) : NaN;
+	const where = placement.machine ? `on ${placement.machine}` : "here";
+	const cacheText = cache.result === "hit" ? `cache hit${cache.source === "remote" ? " (remote)" : ""}` : cache.result;
+	const summary = `${platform} build ${outcome} ${where} in ${formatElapsed(durationMs)} (${cacheText})`;
+	const why = failure ? `: ${[failure.code, failure.message].filter(Boolean).join(": ") || "no reason recorded"}` : "";
+	return {
+		ts: run.now,
+		src: "builds",
+		level: outcome === "succeeded" ? "info" : outcome === "cancelled" ? "warn" : "error",
+		msg: `${summary}${why}`,
+		event: "build",
+		id: run.id,
+		startedAt: Number.isFinite(startedAt) ? startedAt : run.now - durationMs,
+		project: run.root,
+		workspace: run.workspace,
+		branch: run.branch,
+		platform,
+		...scheme ? { scheme } : {},
+		...platform === "android" && configuration ? { variant: configuration } : {},
+		configuration,
+		placement,
+		cache,
+		durationMs,
+		phases: wholePhaseMs(run.phases),
+		...Object.keys(offloadPhases).length ? { offloadPhases } : {},
+		outcome,
+		...failure ? { failure } : {},
+		...device ? { device: {
+			name: device,
+			...runtime ? { runtime } : {}
+		} } : {},
+		...run.loadPerCore === void 0 ? {} : { loadPerCore: run.loadPerCore },
+		...run.boot && Number.isFinite(bootStartedAt) ? { boot: {
+			startedAt: bootStartedAt,
+			loadPerCore: run.boot.loadPerCore
+		} } : {},
+		stimVersion: run.version
+	};
+}
+function lineId(line) {
+	try {
+		const parsed = JSON.parse(line);
+		return typeof parsed === "object" && parsed !== null && "id" in parsed ? parsed.id : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The ledger file's text after appending `line`, keeping only the newest `cap` complete records. A run that records
+* twice (an Android launch that fails after the build was recorded) replaces its earlier record.
+*/
+function appendCapped(existing, line, cap = BUILD_LEDGER_CAP) {
+	const id = lineId(line);
+	const lines = existing.split("\n").filter((each) => each.trim() !== "" && (id === void 0 || lineId(each) !== id));
+	lines.push(line);
+	return `${lines.slice(-cap).join("\n")}\n`;
+}
+function appendBuildLedger(record, file = buildLedgerFile()) {
+	withDirLock(buildLedgerLock(), () => {
+		let existing = "";
+		try {
+			existing = readFileSync(file, "utf-8");
+		} catch {}
+		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+		writeFileSync(tmp, appendCapped(existing, JSON.stringify(record)));
+		try {
+			renameSync(tmp, file);
+		} catch (error) {
+			rmSync(tmp, { force: true });
+			throw error;
+		}
+	}, {
+		waitMs: LOCK_WAIT_MS,
+		ensureParent: () => {
+			mkdirSync(dirname(file), { recursive: true });
+			mkdirSync(dirname(buildLedgerLock()), { recursive: true });
+		}
+	});
+}
+/** Records one finished build in the ledger. A failure to do so never changes the run, so it is ignored. */
+function writeBuildLedger(root, run) {
+	try {
+		const branch = gitQuiet(root, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], { timeoutMs: GIT_TIMEOUT_MS })?.trim() || null;
+		appendBuildLedger(buildLedgerRecord({
+			...run,
+			id: run.id ?? randomUUID(),
+			root,
+			workspace: workspaceName(root),
+			branch,
+			version: STIM_VERSION
+		}));
+	} catch {}
+}
+//#endregion
+//#region src/engine/build-progress.ts
+const ACTIVE_BUILD_KEY = "activeBuild";
+const NO_BUILD_PROGRESS = {
+	step: () => {},
+	activity: () => {},
+	estimate: () => {},
+	miss: () => {},
+	hit: () => {},
+	deviceSetup: () => {},
+	deviceSetupKnown: () => void 0,
+	place: () => {},
+	waitingOn: () => {},
+	waitingFor: () => {},
+	bootStarted: () => {},
+	output: () => {},
+	durations: () => ({}),
+	phase: () => null,
+	steps: () => null,
+	clear: () => {}
+};
+/** `writer`, with each record it writes also passed to `progress.output`. */
+function tapBuildLog(writer, progress) {
+	if (progress === NO_BUILD_PROGRESS) return writer;
+	return {
+		get file() {
+			return writer.file;
+		},
+		write(record) {
+			progress.output(record);
+			return writer.write(record);
+		},
+		close: () => writer.close(),
+		get written() {
+			return writer.written;
+		},
+		get dropped() {
+			return writer.dropped;
+		},
+		get lastError() {
+			return writer.lastError;
+		}
+	};
+}
+function runFailureRecord({ code, message, phase }) {
+	return {
+		src: "build",
+		level: "error",
+		event: "run_failed",
+		...code ? { code } : {},
+		...phase ? { phase } : {},
+		msg: [code, message].filter(Boolean).join(": ") || "the run failed"
+	};
+}
+function thrownRunFailureRecord(error, phase) {
+	return runFailureRecord({
+		code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0,
+		message: error instanceof Error ? error.message : String(error),
+		phase
+	});
+}
+const DETAIL_WRITE_MS = 2e3;
+function toolLine(record) {
+	if (!record || typeof record !== "object") return null;
+	const { src, level, msg } = record;
+	return src === "build" && level === "debug" && typeof msg === "string" ? msg : null;
+}
+function writeBuildDetail(root, claimId, detail) {
+	const file = workspaceBuildDetailFile(root);
+	const tmp = `${file}.tmp-${process.pid}`;
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(tmp, JSON.stringify({
+		claimId,
+		detail
+	}));
+	renameSync(tmp, file);
+}
+const COLD_PHASES = [
+	"prebuild",
+	"pods",
+	"compile"
+];
+const HIT_PHASES = ["install", "launch"];
+function settledOutcome(phase, entered) {
+	if (COLD_PHASES.includes(phase)) return "cold";
+	if (phase === "device") return entered.some((entry) => entry.phase === "cache-lookup") ? "hit" : null;
+	return HIT_PHASES.includes(phase) ? "hit" : null;
+}
+function projectHistory(projectKey) {
+	try {
+		return readStats$1().record?.history?.[projectKey];
+	} catch {
+		return;
+	}
+}
+function startBuildProgress({ root, platform, slot, claim, now = Date.now, load = () => loadPerCore().loadPerCore, note = () => {} }) {
+	const startedAt = new Date(now()).toISOString();
+	const record = {
+		platform,
+		slot,
+		startedAt,
+		phase: "prepare",
+		phaseStartedAt: startedAt,
+		phases: [{
+			phase: "prepare",
+			startedAt
+		}],
+		claim: {
+			root: claim.root,
+			path: claim.path,
+			claimId: claim.claimId,
+			pid: claim.owner.pid
+		},
+		loadPerCore: load()
+	};
+	let warned = false;
+	const guard = (fn) => {
+		try {
+			fn();
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
+		...before(state),
+		[ACTIVE_BUILD_KEY]: record
+	})));
+	write(withInterruptedBuild);
+	const phases = trace.phases(`${platform} build`);
+	phases.enter("prepare");
+	let projectKey = null;
+	const parser = createBuildDetailParser();
+	let detailWrittenAt = -Infinity;
+	let detailTimer = null;
+	const flushDetail = () => {
+		detailTimer = null;
+		detailWrittenAt = now();
+		const detail = parser.detail(new Date(detailWrittenAt).toISOString());
+		if (detail) guard(() => writeBuildDetail(root, record.claim.claimId, detail));
+	};
+	const settle = (outcome) => {
+		record.outcome = outcome;
+		if (projectKey && platform !== "macos") record.estimate = estimateBuild(projectHistory(projectKey), platform, outcome, record.deviceSetup);
+	};
+	const waits = /* @__PURE__ */ new Map();
+	return {
+		step(phase) {
+			if (phase === record.phase) return;
+			const at = new Date(now()).toISOString();
+			record.phase = phase;
+			record.phaseStartedAt = at;
+			record.phases.push({
+				phase,
+				startedAt: at
+			});
+			phases.enter(phase);
+			if (phase !== "wait") delete record.waitingOn;
+			delete record.activity;
+			const outcome = record.outcome || platform === "macos" ? null : settledOutcome(phase, record.phases);
+			if (outcome) settle(outcome);
+			write();
+		},
+		activity(name, at) {
+			if ((record.activity?.name ?? null) === name) return;
+			if (name) record.activity = {
+				name,
+				startedAt: new Date(at ?? now()).toISOString()
+			};
+			else delete record.activity;
+			write();
+		},
+		estimate(key) {
+			if (platform === "macos") return;
+			projectKey = key;
+			record.estimate = estimateBuild(projectHistory(key), platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+			write();
+		},
+		miss(reason, provisional = false) {
+			record.missReason = reason;
+			settle("cold");
+			if (provisional) record.missProvisional = true;
+			else delete record.missProvisional;
+			write();
+		},
+		hit() {
+			delete record.missReason;
+			delete record.missProvisional;
+			settle("hit");
+			write();
+		},
+		deviceSetup(setup) {
+			if (setup === void 0) return;
+			record.deviceSetup = setup;
+			write();
+		},
+		deviceSetupKnown() {
+			return record.deviceSetup;
+		},
+		place(remote) {
+			const current = record.placement;
+			if (remote && current?.host === remote.host && current.phase === remote.phase) return;
+			if (current) record.offload = withOffloadPhase(record.offload, current, now());
+			if (!remote) {
+				if (!current) return;
+				delete record.placement;
+				return write();
+			}
+			const at = new Date(now()).toISOString();
+			record.placement = {
+				host: remote.host,
+				phase: remote.phase,
+				startedAt: current?.host === remote.host ? current.startedAt : at,
+				phaseStartedAt: at
+			};
+			write();
+		},
+		waitingFor(info, kind) {
+			if (info) waits.set(info.kind, info);
+			else if (kind) waits.delete(kind);
+			else waits.clear();
+			const first = [...waits.values()].toSorted((a, b) => Date.parse(a.since) - Date.parse(b.since))[0];
+			if (first) record.waitingFor = first;
+			else delete record.waitingFor;
+			write();
+		},
+		bootStarted() {
+			if (record.boot) return;
+			record.boot = {
+				startedAt: new Date(now()).toISOString(),
+				loadPerCore: load()
+			};
+			write();
+		},
+		waitingOn(holder) {
+			if (holder === null) {
+				if (!record.waitingOn) return;
+				delete record.waitingOn;
+			} else {
+				if (record.waitingOn?.path === holder) return;
+				record.waitingOn = { path: holder };
+			}
+			write();
+		},
+		output(line) {
+			const msg = toolLine(line);
+			if (msg === null || !parser.push(msg) || detailTimer) return;
+			const wait = detailWrittenAt + DETAIL_WRITE_MS - now();
+			if (wait <= 0) return flushDetail();
+			detailTimer = setTimeout(flushDetail, wait);
+			detailTimer.unref?.();
+		},
+		durations() {
+			return phaseDurations(record.phases, now());
+		},
+		phase() {
+			return record.phase;
+		},
+		steps() {
+			const detail = parser.detail("");
+			return detail?.unit === "steps" ? detail.total : null;
+		},
+		clear() {
+			phases.end();
+			if (detailTimer) clearTimeout(detailTimer);
+			detailTimer = null;
+			guard(() => rmSync(workspaceBuildDetailFile(root), { force: true }));
+			guard(() => {
+				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
+			});
+		}
+	};
+}
+/** `offload` with the time `placement` has spent in its current phase as of `now` added to that phase. */
+function withOffloadPhase(offload, placement, now) {
+	const phaseMs = { ...offload?.phaseMs };
+	const ms = Math.max(0, now - Date.parse(placement.phaseStartedAt));
+	if (Number.isFinite(ms)) phaseMs[placement.phase] = (phaseMs[placement.phase] ?? 0) + ms;
+	return {
+		host: placement.host,
+		phaseMs
+	};
+}
+function phaseDurations(phases, now) {
+	const out = {};
+	phases.forEach(({ phase, startedAt }, index) => {
+		const start = Date.parse(startedAt);
+		const next = phases[index + 1];
+		const end = next ? Date.parse(next.startedAt) : now;
+		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
+		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
+	});
+	return out;
+}
+function completedPhaseDurations(phases) {
+	if (phases.length < 2) return void 0;
+	const durations = phaseDurations(phases.slice(0, -1), Date.parse(phases.at(-1).startedAt));
+	return Object.keys(durations).length ? durations : void 0;
+}
+const HISTORY_FIELDS = [
+	"devicePlacement",
+	"platform",
+	"status",
+	"configuration",
+	"fingerprint",
+	"cacheKey",
+	"cacheHit",
+	"cacheSkipped",
+	"durationMs",
+	"startedAt",
+	"errorCode",
+	"missReason",
+	"buildMachine",
+	"builtOn",
+	"offloadedTo",
+	"offloadFallback",
+	"diagnostics",
+	"compileSteps"
+];
+function withHistoryEntry(state, platform, entry) {
+	const saved = state[BUILD_HISTORY_KEY];
+	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
+	const list = Array.isArray(history[platform]) ? history[platform] : [];
+	return {
+		...state,
+		[BUILD_HISTORY_KEY]: {
+			...history,
+			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
+		}
+	};
+}
+function finishedResult(record) {
+	if (record.status === "ok") return "succeeded";
+	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
+}
+function recordFinishedBuild(root, recorded, { update = updateWorkspaceState, now = Date.now, artifactOnly = false, ledger = writeBuildLedger } = {}) {
+	const { ledger: extras, ...record } = recorded;
+	const ran = {};
+	try {
+		updateFinishedBuild(root, record, ran, {
+			update,
+			now,
+			artifactOnly
+		});
+	} finally {
+		ledger(root, {
+			now: now(),
+			outcome: finishedResult(record),
+			record,
+			extras: isJsonObject(extras) ? extras : {},
+			phases: {},
+			phase: null,
+			...ran
+		});
+	}
+}
+function updateFinishedBuild(root, record, ran, { update, now, artifactOnly }) {
+	const platform = record.platform;
+	update(root, (state) => {
+		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+		const own = active?.platform === platform ? active : null;
+		const phases = own ? phaseDurations(own.phases, now()) : {};
+		if (own) {
+			const offload = own.placement ? withOffloadPhase(own.offload, own.placement, now()) : own.offload;
+			Object.assign(ran, {
+				id: own.claim.claimId,
+				phases,
+				phase: own.phase,
+				...offload ? { offload } : {},
+				...own.loadPerCore === void 0 ? {} : { loadPerCore: own.loadPerCore },
+				...own.boot ? { boot: own.boot } : {}
+			});
+		}
+		const entry = {
+			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
+			result: finishedResult(record),
+			slot: own?.slot ?? "default",
+			phases
+		};
+		if (artifactOnly || platform === "macos") return withHistoryEntry(state, platform, entry);
+		const slot = own?.slot ?? "default";
+		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
+		const savedSlot = isJsonObject(slots[slot]) ? slots[slot] : {};
+		const savedDevice = slot === "default" ? state[platform] : savedSlot[platform];
+		if (record.devicePlacement || isJsonObject(savedDevice)) {
+			const device = isJsonObject(savedDevice) ? { ...savedDevice } : {};
+			if (record.devicePlacement) device.devicePlacement = record.devicePlacement;
+			else delete device.devicePlacement;
+			state = slot === "default" ? {
+				...state,
+				[platform]: device
+			} : {
+				...state,
+				deviceSlots: {
+					...slots,
+					[slot]: {
+						...savedSlot,
+						[platform]: device
+					}
+				}
+			};
+		}
+		return withHistoryEntry({
+			...state,
+			lastBuild: record,
+			[LAST_BUILD_KEYS[platform]]: record
+		}, platform, entry);
+	});
+}
+/** Adds one phase's duration to the recorded run of `platform` that started at `startedAt`. */
+function recordBuildPhase(root, platform, startedAt, phase, ms) {
+	updateWorkspaceState(root, (state) => {
+		const saved = state[BUILD_HISTORY_KEY];
+		const list = isJsonObject(saved) && Array.isArray(saved[platform]) ? saved[platform] : [];
+		const index = list.findIndex((entry) => isJsonObject(entry) && entry.startedAt === startedAt);
+		const entry = list[index];
+		if (!isJsonObject(entry)) return state;
+		const phases = isJsonObject(entry.phases) ? entry.phases : {};
+		const next = [...list];
+		next[index] = {
+			...entry,
+			phases: {
+				...phases,
+				[phase]: Math.round(ms)
+			}
+		};
+		return {
+			...state,
+			[BUILD_HISTORY_KEY]: {
+				...saved,
+				[platform]: next
+			}
+		};
+	});
+}
+function withInterruptedBuild(state) {
+	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+	if (!left) return state;
+	const last = state[BUILD_HISTORY_KEY]?.[left.platform]?.[0];
+	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
+	return withHistoryEntry(state, left.platform, {
+		platform: left.platform,
+		status: "failed",
+		result: "interrupted",
+		slot: left.slot,
+		configuration: null,
+		fingerprint: null,
+		cacheKey: null,
+		cacheHit: false,
+		cacheSkipped: false,
+		durationMs: null,
+		startedAt: left.startedAt,
+		phases: {
+			...phaseDurations(left.phases, Date.parse(left.phaseStartedAt)),
+			[left.phase]: 0
+		}
+	});
+}
+function parseActiveBuild(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const claim = record.claim;
+	if (record.platform !== "ios" && record.platform !== "android" && record.platform !== "macos") return null;
+	if (!isPhase(record.phase)) return null;
+	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
+	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
+	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
+	const missReason = parseMissReason(record.missReason);
+	const placement = parsePlacement(record.placement);
+	const waitingOn = parseWaitingOn(record.waitingOn);
+	const waitingFor = parseWaitingFor(record.waitingFor);
+	const estimate = parseEstimate(record.estimate);
+	const activity = parseActivity(record.activity);
+	const offload = parseOffload(record.offload);
+	const boot = parseBoot(record.boot);
+	return {
+		platform: record.platform,
+		slot: typeof record.slot === "string" ? record.slot : "default",
+		startedAt: record.startedAt,
+		phase: record.phase,
+		phaseStartedAt: record.phaseStartedAt,
+		phases,
+		...missReason ? { missReason } : {},
+		...missReason && record.missProvisional === true ? { missProvisional: true } : {},
+		...placement ? { placement } : {},
+		...offload ? { offload } : {},
+		...waitingOn ? { waitingOn } : {},
+		...waitingFor ? { waitingFor } : {},
+		...typeof record.deviceSetup === "boolean" ? { deviceSetup: record.deviceSetup } : {},
+		...record.outcome === "hit" || record.outcome === "cold" ? { outcome: record.outcome } : {},
+		...estimate ? { estimate } : {},
+		...activity ? { activity } : {},
+		...isLoad(record.loadPerCore) ? { loadPerCore: record.loadPerCore } : {},
+		...boot ? { boot } : {},
+		claim: {
+			root: claim.root,
+			path: typeof claim.path === "string" ? claim.path : "",
+			claimId: claim.claimId,
+			pid: typeof claim.pid === "number" ? claim.pid : 0
+		}
+	};
+}
+function isLoad(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function parseBoot(value) {
+	if (!isJsonObject(value) || typeof value.startedAt !== "string" || !isLoad(value.loadPerCore)) return null;
+	return {
+		startedAt: value.startedAt,
+		loadPerCore: value.loadPerCore
+	};
+}
+function parseOffload(value) {
+	if (!isJsonObject(value) || typeof value.host !== "string" || !isJsonObject(value.phaseMs)) return null;
+	const phaseMs = {};
+	for (const [phase, ms] of Object.entries(value.phaseMs)) if (typeof ms === "number" && Number.isFinite(ms) && ms >= 0) phaseMs[phase] = ms;
+	return {
+		host: value.host,
+		phaseMs
+	};
+}
+function parsePlacement(value) {
+	if (!value || typeof value !== "object") return null;
+	const { host, phase, startedAt, phaseStartedAt } = value;
+	if ([
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	].some((field) => typeof field !== "string")) return null;
+	return {
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	};
+}
+function parseWaitingFor(value) {
+	if (!value || typeof value !== "object") return null;
+	const { kind, inUse, max, since } = value;
+	if (kind !== "build-slot" && kind !== "device-slot") return null;
+	if (!Number.isInteger(inUse) || inUse < 0 || !Number.isInteger(max) || max <= 0) return null;
+	if (typeof since !== "string" || !Number.isFinite(Date.parse(since))) return null;
+	return {
+		kind,
+		inUse,
+		max,
+		since
+	};
+}
+function parseActivity(value) {
+	if (!value || typeof value !== "object") return null;
+	const { name, startedAt } = value;
+	if (name !== "booting" && name !== "bundling" && name !== "waiting-ready") return null;
+	return typeof startedAt === "string" ? {
+		name,
+		startedAt
+	} : null;
+}
+function parseWaitingOn(value) {
+	const path = value?.path;
+	return typeof path === "string" && path ? { path } : null;
+}
+function parseEstimate(value) {
+	if (!value || typeof value !== "object") return null;
+	const { outcome, expectedMs, basis, phaseMs, planned } = value;
+	if (outcome !== null && outcome !== "hit" && outcome !== "cold") return null;
+	if (expectedMs !== null && typeof expectedMs !== "number") return null;
+	if (typeof basis !== "number" || !Array.isArray(planned) || !phaseMs || typeof phaseMs !== "object") return null;
+	const durations = Object.entries(phaseMs).filter((entry) => isPhase(entry[0]) && typeof entry[1] === "number");
+	return {
+		outcome,
+		expectedMs,
+		basis,
+		phaseMs: Object.fromEntries(durations),
+		planned: planned.filter(isPhase)
+	};
+}
+function isPhase(value) {
+	return BUILD_PHASES.includes(value);
+}
+function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
+	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
+	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
+	return survey.unresolved.length ? "unknown" : "stale";
+}
+function median(values) {
+	if (!values.length) return null;
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function estimateBuild(history, platform, known, deviceSetup) {
+	const lists = platform === "macos" ? void 0 : history?.[platform];
+	const outcome = known ?? latestOutcome(lists);
+	const samples = matchDeviceSetup(outcome && lists?.[outcome] || [], deviceSetup);
+	const phaseMs = {};
+	const planned = [];
+	for (const phase of BUILD_PHASES) {
+		const durations = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
+		const ms = median(durations);
+		if (ms === null) continue;
+		phaseMs[phase] = ms;
+		if (durations.length * 2 >= samples.length) planned.push(phase);
+	}
+	return {
+		outcome,
+		expectedMs: median(samples.map((sample) => sample.durationMs)),
+		basis: samples.length,
+		phaseMs,
+		planned
+	};
+}
+const MIN_TAGGED_SAMPLES = 3;
+function matchDeviceSetup(samples, deviceSetup) {
+	if (deviceSetup === void 0) return samples;
+	const tagged = samples.filter((sample) => sample.deviceSetup === deviceSetup);
+	if (deviceSetup || tagged.length >= MIN_TAGGED_SAMPLES) return tagged;
+	return samples.filter((sample) => sample.deviceSetup !== true);
+}
+function latestOutcome(lists) {
+	let latest = null;
+	for (const outcome of ["hit", "cold"]) {
+		const last = lists?.[outcome]?.at(-1);
+		const at = last ? Date.parse(last.at) : NaN;
+		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
+			outcome,
+			at
+		};
+	}
+	return latest?.outcome ?? null;
+}
+function buildReport(record, { state, history }) {
+	const estimate = record.estimate ?? estimateBuild(history, record.platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+	const plannedPhases = estimate.planned.flatMap((phase) => {
+		const expectedMs = estimate.phaseMs[phase];
+		return expectedMs === void 0 ? [] : [{
+			phase,
+			expectedMs
+		}];
+	});
+	const completedPhaseMs = completedPhaseDurations(record.phases);
+	return {
+		platform: record.platform,
+		slot: record.slot,
+		state,
+		phase: record.phase,
+		startedAt: record.startedAt,
+		phaseStartedAt: record.phaseStartedAt,
+		outcome: estimate.outcome,
+		outcomeKnown: record.outcome !== void 0,
+		...record.outcome && record.phases.some(({ phase }) => phase === "cache-lookup") ? { cacheLookupOutcome: record.outcome === "hit" ? "hit" : "miss" } : {},
+		expectedMs: estimate.expectedMs,
+		expectedPhaseMs: estimate.phaseMs[record.phase] ?? null,
+		...completedPhaseMs ? { completedPhaseMs } : {},
+		basis: estimate.basis,
+		plannedPhases: plannedPhases.length ? plannedPhases : null,
+		...record.missReason ? { missReason: record.missReason } : {},
+		...record.missReason && record.missProvisional ? { missProvisional: true } : {},
+		placement: record.placement ?? "local",
+		...record.waitingOn ? { waitingOn: record.waitingOn } : {},
+		...record.waitingFor ? { waitingFor: record.waitingFor } : {},
+		...record.activity ? { activity: { ...record.activity } } : {}
+	};
+}
+/**
+* The run's `bundling` activity with Metro's percent, when the request Metro reports in flight is the one the activity
+* started on: same platform and same start, since both come from the request's `bundle_response_started` record.
+*/
+function bundlingActivity(activity, platform, bundle) {
+	if (activity?.name !== "bundling" || !bundle?.bundling || bundle.percent === void 0) return activity;
+	if (bundle.platform !== platform || bundle.startedAt !== activity.startedAt) return activity;
+	return {
+		...activity,
+		percent: bundle.percent
+	};
+}
+function remainingText(remainingMs) {
+	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
+}
+function activityText({ name, percent, startedAt }, now) {
+	return `${name === "booting" ? "booting" : name === "waiting-ready" ? "waiting for app ready" : percent === void 0 ? "bundling JS" : `bundling JS ${percent}%`}, ${formatElapsed(Math.max(0, now - Date.parse(startedAt)))}`;
+}
+function buildStatusLine(report, now) {
+	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
+	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
+	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
+	const remote = typeof report.placement === "object" ? ` on ${report.placement.host} (${report.placement.phase}, ${formatElapsed(Math.max(0, now - Date.parse(report.placement.phaseStartedAt)))})` : "";
+	const waiting = report.waitingOn ? ` on ${report.waitingOn.path}` : "";
+	const activity = report.activity ? ` (${activityText(report.activity, now)})` : "";
+	const head = `build: ${report.platform}${slot} ${report.phase}${activity}${waiting}${remote}, ${formatElapsed(elapsedMs)} elapsed`;
+	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
+	if (report.expectedMs === null) return head;
+	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
+	const remainingMs = report.expectedMs - elapsedMs;
+	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
+}
+//#endregion
+//#region src/commands/gc/idle.ts
+function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
+	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
+	const dead = new Set(deadProjects);
+	const found = [];
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		if (dead.has(project)) continue;
+		for (const { slot, platforms } of projectDeviceSlots(record)) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
+				kind: "ios",
+				id: ios.deviceUdid,
+				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "ios",
+					id: ios.deviceUdid,
+					slot,
+					workspace: project
+				})
+			});
+			const android = platforms.android;
+			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
+			if (android?.avdName && serial) found.push({
+				kind: "android",
+				id: android.avdName,
+				name: android.avdName,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "android",
+					id: serial,
+					slot,
+					workspace: project
+				})
+			});
+		}
+	}
+	return found;
+}
+function findIdleDevices({ buildInProgress, now, ...inputs }) {
+	return idleDevicesFromActivity(findOwnedDeviceActivity(inputs), buildInProgress, now);
+}
+function idleDevicesFromActivity(devices, buildInProgress, now) {
+	return devices.filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
+		kind,
+		id,
+		name,
+		project,
+		slot,
+		lastActivityAt: activity.lastActivityAt ?? null,
+		idleForMs: idleForMs(activity, now),
+		buildInProgress: buildInProgress(project)
+	}));
+}
+function idleShutdownCandidates(devices, idleMs) {
+	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
+}
+function parseIdleDuration(value) {
+	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
+	if (!match) return null;
+	const unit = {
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	return Number(match[1]) * unit;
+}
+function workspaceBuildInProgress(project) {
+	const record = parseActiveBuild(readWorkspaceState$1(project)?.[ACTIVE_BUILD_KEY]);
+	if (!record) return false;
+	try {
+		return activeBuildState(record.claim) !== "stale";
+	} catch {
+		return true;
+	}
+}
+function deviceActivityInputs(config, sims, now, env) {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return {
+		config,
+		sims,
+		readActivity: createActivityReader({
+			now,
+			env
+		}),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+function collectOwnedDeviceActivity(config, sims, now = Date.now(), env) {
+	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now, env));
+}
+function collectIdleDevices(config, sims, deadProjects, now = Date.now(), env) {
+	return findIdleDevices({
+		...deviceActivityInputs(config, sims, now, env),
+		deadProjects,
+		now,
+		buildInProgress: workspaceBuildInProgress
+	});
+}
+async function deviceActivityInputsAsync(config, sims, now, env, deadProjects = [], signal, operation) {
+	const resolve = ownedAvdSerialResolverAsync({
+		timeoutMs: 5e3,
+		signal,
+		operation
+	});
+	const serials = /* @__PURE__ */ new Map();
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		signal?.throwIfAborted();
+		if (deadProjects.includes(project)) continue;
+		for (const { platforms } of projectDeviceSlots(record)) {
+			const android = platforms.android;
+			if (!android?.owned || !android.avdName || serials.has(android.avdName)) continue;
+			try {
+				serials.set(android.avdName, (await resolve(android.avdName)).serial ?? null);
+			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError) throw error;
+				signal?.throwIfAborted();
+				serials.set(android.avdName, null);
+			}
+		}
+	}
+	return {
+		config,
+		sims,
+		readActivity: createActivityReaderAsync({
+			now,
+			env,
+			signal,
+			operation
+		}),
+		androidSerial: (name) => serials.get(name) ?? null
+	};
+}
+async function collectOwnedDeviceActivityAsync(config, sims, now = Date.now(), env, signal, operation) {
+	const devices = findOwnedDeviceActivity(await deviceActivityInputsAsync(config, sims, now, env, [], signal, operation));
+	return Promise.all(devices.map(async (device) => Object.assign({}, device, { activity: await device.activity })));
+}
+async function collectIdleDevicesAsync(config, sims, deadProjects, now = Date.now(), env, signal, operation) {
+	const pending = findOwnedDeviceActivity({
+		...await deviceActivityInputsAsync(config, sims, now, env, deadProjects, signal, operation),
+		deadProjects
+	});
+	return idleDevicesFromActivity(await Promise.all(pending.map(async (device) => Object.assign({}, device, { activity: await device.activity }))), workspaceBuildInProgress, now);
+}
+function idleDeviceLines(devices) {
+	if (devices.length === 0) return [];
+	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
+		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
+		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
+		const build = d.buildInProgress ? ", build in progress" : "";
+		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
+	})];
+}
+async function shutDownIdleDevices(devices, idleMs, recollect, { log, record } = GC_OUTPUT, signal, operation) {
+	signal?.throwIfAborted();
+	const candidates = idleShutdownCandidates(devices, idleMs);
+	const shutDown = [];
+	if (candidates.length === 0) {
+		log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
+		return {
+			failures: 0,
+			shutDown
+		};
+	}
+	const fresh = idleShutdownCandidates(await recollect(), idleMs);
+	signal?.throwIfAborted();
+	let failures = 0;
+	for (const device of candidates) {
+		signal?.throwIfAborted();
+		const what = `${device.kind} ${device.name}`;
+		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
+		if (!current) {
+			log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
+			record("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: `it is no longer idle for ${formatLongDuration(idleMs)}`
+			});
+			continue;
+		}
+		const outcome = device.kind === "ios" ? await teardownOwnedIosSim(device.id, {
+			label: device.name,
+			operation
+		}) : await teardownOwnedAvd(device.id, {
+			owner: {
+				projectPath: device.project,
+				slot: device.slot
+			},
+			operation
+		});
+		if (outcome.status === "torn-down") {
+			shutDown.push(device);
+			log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
+			record("idleDevice", "done", device.name, {
+				id: device.id,
+				detail: `idle ${formatLongDuration(current.idleForMs)}`
+			});
+		} else if (outcome.status === "missing") log(chalk.dim(`${what} is already gone; nothing to shut down.`));
+		else if (outcome.status === "skipped") {
+			log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
+			record("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		} else {
+			failures++;
+			log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
+			record("idleDevice", "failed", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		}
+	}
+	return {
+		failures,
+		shutDown
+	};
+}
+//#endregion
 //#region src/macos/instances.ts
 const BUNDLE_EXECUTABLE = /^[^/]+\.app\/Contents\/MacOS\/[^/]+$/;
 function bundleDirs(root) {
@@ -1221,10 +2885,20 @@ function failedBundleListing(record, error) {
 	if (!open.trim()) throw unverified(record.pid, `lsof failed (${error.message.split("\n")[0]})`);
 	return open;
 }
+/** The attempt directories under a hosted session's `apps`, each of which holds one `App.app`. */
+function hostedBundleDirs(area) {
+	const apps = join(area, "apps");
+	if (process.platform !== "darwin" || !existsSync(apps)) return [];
+	if (realpathSync(apps) !== apps) throw new Error("Hosted app data resolves outside its private area.");
+	return readdirSync(apps).filter((attempt) => hostedAppAttempt(attempt)).map((attempt) => join(apps, attempt)).filter((dir) => lstatSync(dir, { throwIfNoEntry: false })?.isDirectory());
+}
 /** Verifies owned bundle instances without blocking on process and executable probes. */
-async function runningBundleInstancesAsync(root, operation) {
+function runningBundleInstancesAsync(root, operation) {
+	return runningInstancesInAsync(bundleDirs(root), operation);
+}
+/** Verifies the running copies of app bundles directly inside `dirs`. */
+async function runningInstancesInAsync(dirs, operation) {
 	operation?.signal.throwIfAborted();
-	const dirs = bundleDirs(root);
 	if (!dirs.length) return [];
 	const listing = await runOperationFile(operation, getExecutor(), "ps", [
 		"-axww",
@@ -1853,9 +3527,9 @@ function numberOrNull(v) {
 //#region src/workspace/in-use.ts
 const NATIVE_RUN = "native-run";
 const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
-function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted = true, nativeRun = true } = {}, bundleInstances = bundleInstancePids) {
+function workspaceInUse(root, { supervisor = true, devServer = true, managedLocks = true, hosted = true, nativeRun = true } = {}, bundleInstances = bundleInstancePids) {
 	const reasons = [];
-	if (supervisor) {
+	if (supervisor && devServer) {
 		const project = getProject(root);
 		const target = resolveSupervisorTarget({
 			state: readWorkspaceState$1(root)?.supervisor,
@@ -1864,6 +3538,11 @@ function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted =
 		});
 		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
 		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+		const browser = webFacts(readWebRecord(root));
+		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
+		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
+	}
+	if (supervisor) {
 		const macos = macosAppState(readMacosRecord(root));
 		if (macos?.host) reasons.push(`its macOS app runs on ${macos.host.machine}`);
 		else if (macos?.state === "running" || macos?.state === "orphaned" || macos?.build.state === "running") reasons.push("its macOS app or build is running");
@@ -1877,9 +3556,6 @@ function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted =
 		const runtime = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
 		if (runtime.live.length) reasons.push("its macOS runtime claim is held");
 		else if (runtime.unresolved[0]) reasons.push(`its macOS runtime cannot be verified: ${runtime.unresolved[0].reason}`);
-		const browser = webFacts(readWebRecord(root));
-		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
-		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
 	}
 	if (nativeRun) {
 		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
@@ -1974,6 +3650,63 @@ async function withIdleWorkspace(root, fn, { purpose, operation, signal = operat
 	}
 }
 //#endregion
+//#region src/workspace/regenerable-dirs.ts
+/**
+* Directories that hold only what a build or an install regenerates, relative to an app or package root. ios/build is
+* not one: `pod install` writes the codegen output (build/generated/ios) and, on React Native 0.88, the podspec
+* facades (scripts/cocoapods/rncore_facades.rb) there, the Pods project references them, and only `pod install`
+* recreates them.
+*/
+const ARTIFACT_DIRS = {
+	build: [
+		"android/app/build",
+		"android/build",
+		"android/.gradle",
+		".build"
+	],
+	dependencies: ["node_modules", "ios/Pods"]
+};
+/** The existing real directories among `dirs` under `root`, never through a link. */
+function existingDirsOf(root, dirs) {
+	return dirs.map((dir) => join(root, dir)).filter((path) => {
+		try {
+			return lstatSync(path).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+}
+/**
+* Why `path`, inside the checkout at `root`, must not be deleted as a regenerable directory, or null when it is a real
+* directory inside `root` whose every file git ignores.
+*/
+async function regenerableDirProblem(root, path, signal) {
+	const rel = relative(root, path);
+	try {
+		if (!lstatSync(path).isDirectory()) return "it is not a directory";
+	} catch {
+		return "it is gone";
+	}
+	if (canonicalPath(path) !== join(canonicalPath(root), rel)) return "it or a directory above it is a link, or it lies outside its project";
+	const tracked = await gitQuietAsync(root, [
+		"ls-files",
+		"--",
+		rel
+	], { signal });
+	if (tracked === null) return "git cannot tell whether it holds tracked files";
+	if (tracked.trim()) return "it holds files git tracks";
+	const unignored = await gitQuietAsync(root, [
+		"ls-files",
+		"--others",
+		"--exclude-standard",
+		"--",
+		rel
+	], { signal });
+	if (unignored === null) return "git cannot tell whether it ignores every file in it";
+	if (unignored.trim()) return "it holds files git does not ignore";
+	return null;
+}
+//#endregion
 //#region src/commands/gc/workspaces.ts
 function workspacesRoot() {
 	return join$1(getConfigDir(), "workspaces");
@@ -2091,7 +3824,7 @@ function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse
 			continue;
 		}
 		if (present) continue;
-		if (registryKeys.some((key) => isPathPrefix(projectRoot, key))) continue;
+		if (registryKeys.some((key) => isPathPrefix$1(projectRoot, key))) continue;
 		if (!isMounted(projectRoot)) {
 			skipped.push({
 				dir,
@@ -2153,39 +3886,71 @@ async function collectOrphanedWorkspaces(registryKeys, mountedVolumes, { measure
 		}
 	}
 	if (!measure) return classified;
-	const orphaned = [];
-	for (const entry of classified.orphaned) {
-		operation?.signal.throwIfAborted();
-		const bytes = await measuredDirectorySizeAsync(entry.dir, {
-			timeoutMs: SIZE_TIMEOUT_MS,
-			operation,
-			signal: operation?.signal
-		});
-		orphaned.push({
-			...entry,
-			bytes
-		});
-	}
 	return {
-		orphaned,
+		orphaned: await mapLimited(classified.orphaned, sizeConcurrency(operation), async (entry) => {
+			operation?.signal.throwIfAborted();
+			const bytes = await measuredDirectorySizeAsync(entry.dir, {
+				timeoutMs: SIZE_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			});
+			return {
+				...entry,
+				bytes
+			};
+		}),
 		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. The next stim macos in a cleared workspace is a full Swift build.";
+/** How long after its last ios, android or macos run a workspace keeps its build outputs. */
+const LIGHTEN_AFTER_MS = 9e5;
+const BUILD_CHECKS = {
+	devServer: false,
+	hosted: false,
+	managedLocks: false
+};
+const BUILD_IN_PROGRESS = "a build is in progress";
+/** Why the build outputs of the workspace at `root` are in use: it is building or running a macOS app. */
+function workspaceBuildReasons(root, { nativeRun = true } = {}) {
+	const reasons = workspaceInUse(root, {
+		...BUILD_CHECKS,
+		nativeRun
+	});
+	return workspaceBuildInProgress(root) ? [...reasons, BUILD_IN_PROGRESS] : reasons;
+}
+async function workspaceBuildReasonsAsync(root, signal, operation) {
+	const reasons = await workspaceInUseAsync(root, BUILD_CHECKS, signal, operation);
+	return workspaceBuildInProgress(root) ? [...reasons, BUILD_IN_PROGRESS] : reasons;
+}
+async function inTreeBuildDirs(root, signal) {
+	const dirs = [];
+	for (const path of existingDirsOf(root, ARTIFACT_DIRS.build)) if (!await regenerableDirProblem(root, path, signal)) dirs.push(path);
+	return dirs;
+}
 const WORKSPACE_OUTPUT_DIRS = [
 	"derived-data",
 	"gradle-build",
 	"android-cas",
 	"cache-provider"
 ];
+/** Why a workspace whose last ios, android or macos run was at `nativeUsed` keeps its build outputs, or null. */
+function recentNativeUseReason(nativeUsed, now) {
+	return now - nativeUsed < 9e5 ? `ran ios, android or macos within the last ${LIGHTEN_AFTER_MS / 6e4} minutes` : null;
+}
 const DAY_MS = 864e5;
+function keptByLock(entry) {
+	return entry.keptCode === "locked" || entry.keptCode === "lock-unknown";
+}
 function planWorkspaceOutputs(entries, { olderThan, now }) {
-	return entries.map(({ dir, projectRoot, problem, bytes, lastUsed, inUse }) => {
+	return entries.map(({ dir, projectRoot, problem, inTreeDirs = [], bytes, lastUsed, nativeUsed, inUse, lock }) => {
+		const recentNative = recentNativeUseReason(nativeUsed, now);
 		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];
+		const [keptCode, keptReason] = projectRoot === null ? ["unresolved", `workspace directory not resolved: ${problem ?? "unknown project root"}`] : lock ? [lock === "locked" ? "locked" : "lock-unknown", lockReason(lock)] : inUse.length ? ["in-use", `in use: ${inUse.join("; ")}`] : recentNative ? ["recently-used", recentNative] : 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,
+			inTreeDirs,
 			bytes,
 			idleDays,
 			willClear: keptCode === null,
@@ -2195,6 +3960,11 @@ function planWorkspaceOutputs(entries, { olderThan, now }) {
 	});
 }
 const SIZE_TIMEOUT_MS = 6e4;
+const gitRead = (operation, signal) => ({
+	env: operation?.env,
+	signal: signal ?? operation?.signal,
+	declareFor: operation
+});
 function outputPaths(dir) {
 	const paths = WORKSPACE_OUTPUT_DIRS.map((name) => join$1(dir, name)).filter((path) => existsSync$1(path));
 	const macos = join$1(dir, "macos");
@@ -2204,48 +3974,71 @@ function outputPaths(dir) {
 	} catch {}
 	return paths;
 }
-async function outputBytes(paths, timeoutMs, signal, operation) {
-	let total = 0;
-	for (const path of paths) {
-		const size = await measuredDirectorySizeAsync(path, {
+async function outputBytes(entries, timeoutMs, signal, operation) {
+	const sizes = await mapLimited(entries.flatMap((paths, index) => paths.map((path) => ({
+		path,
+		index
+	}))), sizeConcurrency(operation), async ({ path, index }) => ({
+		index,
+		size: await measuredDirectorySizeAsync(path, {
 			timeoutMs,
 			signal,
 			operation
-		});
-		if (size === null) return null;
-		total += size;
-	}
-	return total;
+		})
+	}));
+	return entries.map((_, index) => {
+		const own = sizes.filter((size) => size.index === index).map((size) => size.size);
+		return own.includes(null) ? null : own.reduce((total, size) => total + (size ?? 0), 0);
+	});
 }
-function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS, signal, operation }) {
+function collectWorkspaceOutputs({ olderThan, now, exclude = [], only, measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS, signal, operation, lighten = false }) {
 	const mountedVolumes = listMountedVolumes();
-	const outputEntries = (entries) => entries.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);
+	const outputEntries = (entries, inTree = /* @__PURE__ */ new Map()) => entries.filter((entry) => !exclude.includes(entry.dir)).filter((entry) => only === void 0 || entry.projectRoot !== null && canonicalPath(entry.projectRoot) === only).filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => {
+		const inTreeDirs = inTree.get(entry.dir) ?? [];
+		return Object.assign({}, entry, {
+			inTreeDirs,
+			paths: [...outputPaths(entry.dir), ...inTreeDirs]
+		});
+	}).filter((entry) => entry.paths.length > 0);
 	const report = (sizes) => ({
 		root: workspacesRoot(),
-		workspaces: planWorkspaceOutputs(sizes.map((entry) => Object.assign({}, entry, { lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot) })), {
+		workspaces: planWorkspaceOutputs(sizes.map((entry) => Object.assign({}, entry, {
+			lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
+			nativeUsed: lighten && entry.projectRoot !== null ? lastNativeUseFrom(readWorkspaceState$1(entry.projectRoot)) : NaN
+		})), {
 			olderThan,
 			now
 		})
 	});
+	const inUseOf = (root) => lighten ? workspaceBuildReasons(root) : workspaceInUse(root);
 	if (!measure && !signal) return report(outputEntries(listWorkspaceDirs()).map(({ paths: _paths, ...entry }) => Object.assign({}, entry, {
 		bytes: null,
-		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
+		inUse: entry.projectRoot === null ? [] : inUseOf(entry.projectRoot),
+		lock: entry.projectRoot === null ? null : worktreeLock(entry.projectRoot)
 	})));
 	return (async () => {
 		const sizes = [];
-		const entries = outputEntries(await listWorkspaceDirsAsync(signal));
-		for (const { paths, ...entry } of entries) {
+		const listed = await listWorkspaceDirsAsync(signal);
+		const inTree = /* @__PURE__ */ new Map();
+		if (lighten) {
+			for (const { dir, projectRoot } of listed) if (projectRoot !== null && !exclude.includes(dir)) inTree.set(dir, await inTreeBuildDirs(projectRoot, signal));
+		}
+		const entries = outputEntries(listed, inTree);
+		const bytes = measure ? await outputBytes(entries.map((entry) => entry.paths), sizeTimeoutMs, signal, operation) : [];
+		const locks = await mapLimited(entries, sizeConcurrency(operation), async ({ projectRoot }) => projectRoot === null ? null : worktreeLockAsync(projectRoot, gitRead(operation, signal)));
+		for (const [index, { paths: _paths, ...entry }] of entries.entries()) {
 			signal?.throwIfAborted();
 			sizes.push({
 				...entry,
-				bytes: measure ? await outputBytes(paths, sizeTimeoutMs, signal, operation) : null,
-				inUse: entry.projectRoot === null ? [] : signal ? await workspaceInUseAsync(entry.projectRoot, {}, signal, operation) : workspaceInUse(entry.projectRoot)
+				bytes: bytes[index] ?? null,
+				lock: locks[index] ?? null,
+				inUse: entry.projectRoot === null ? [] : !signal ? inUseOf(entry.projectRoot) : lighten ? await workspaceBuildReasonsAsync(entry.projectRoot, signal, operation) : await workspaceInUseAsync(entry.projectRoot, {}, signal, operation)
 			});
 		}
 		return report(sizes);
 	})();
 }
-async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), operation, signal = operation?.signal }, { log, record } = GC_OUTPUT) {
+async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), operation, signal = operation?.signal, lighten = false }, { log, record } = GC_OUTPUT) {
 	let failures = 0;
 	let cleared = 0;
 	const clearedRoots = [];
@@ -2269,13 +4062,20 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), oper
 					...entry,
 					problem: null,
 					lastUsed: workspaceLastUsed(root),
-					inUse: []
+					nativeUsed: lighten ? lastNativeUseFrom(readWorkspaceState$1(root)) : NaN,
+					inUse: lighten && workspaceBuildInProgress(root) ? [BUILD_IN_PROGRESS] : [],
+					lock: await worktreeLockAsync(root, gitRead(operation, signal))
 				}], {
 					olderThan,
 					now
 				});
 				if (again?.keptReason) return again.keptReason;
-				for (const path of outputPaths(entry.dir)) {
+				const inTree = [];
+				for (const path of lighten ? existingDirsOf(root, ARTIFACT_DIRS.build) : []) inTree.push({
+					path,
+					problem: await regenerableDirProblem(root, path, signal)
+				});
+				for (const path of [...outputPaths(entry.dir), ...inTree.filter((dir) => !dir.problem).map((dir) => dir.path)]) {
 					signal?.throwIfAborted();
 					await rm(path, {
 						recursive: true,
@@ -2283,11 +4083,13 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), oper
 					});
 				}
 				signal?.throwIfAborted();
+				for (const { path, problem } of inTree) if (problem) log(chalk.yellow(`Kept ${path}: ${problem}`));
 				return null;
 			}, {
 				purpose: "gc",
 				signal,
-				operation
+				operation,
+				...lighten ? BUILD_CHECKS : {}
 			});
 		} catch (error) {
 			if (error instanceof WorkspaceProcessCleanupError) throw error;
@@ -2311,10 +4113,13 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), oper
 		}
 		cleared += entry.bytes ?? 0;
 		clearedRoots.push(root);
-		log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+		log(chalk.green(lighten ? `Lightened ${root}: freed ${sizeText(entry.bytes)} of build outputs` : `Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
 		record("workspaceOutputs", "done", root, { bytes: entry.bytes });
 	}
-	if (cleared) log(chalk.dim(`Cleared ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
+	if (cleared) {
+		const count = `${clearedRoots.length} workspace${clearedRoots.length === 1 ? "" : "s"}`;
+		log(chalk.dim(`${lighten ? `Lightened ${count}, freeing` : "Cleared"} ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
+	}
 	return {
 		failures,
 		cleared: clearedRoots
@@ -2322,7 +4127,7 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), oper
 }
 function stillOrphaned({ dir, projectRoot }) {
 	if (readRecordedRoot(dir, basename$1(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
-	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
+	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix$1(projectRoot, key));
 }
 async function deleteOrphanedWorkspaces(orphaned, output = GC_OUTPUT, operation) {
 	let failures = 0;
@@ -2381,4 +4186,4 @@ function sizeText(bytes) {
 	return bytes === null ? "size unknown" : formatBytes(bytes);
 }
 //#endregion
-export { teardownOwnedIosSim as A, GC_OUTPUT as B, withManagedTunnelRemovalLock as C, teardownBrowserHeld as D, eraseParkedIosSim as E, measureDu as F, takeGcResults as H, writeUsageCache as I, acquireBuildSlot as L, teardownParkedIosSim as M, probePublicHttp as N, teardownOwnedAvd as O, canonical$1 as P, listBuildSlots as R, withManagedTunnelLock as S, eraseParkedAvd as T, createGcResults as V, startTunnelSequence as _, collectWorkspaceOutputs as a, withManagedRemoteWorktreeLock as b, listWorkspaceDirs as c, workspaceDirRemoved as d, emptyWorkspaceDir as f, resolveSupervisorTarget as g, workspaceInUseAsync as h, collectOrphanedWorkspaces as i, teardownParkedAvd as j, teardownOwnedBrowser as k, rootPresence as l, workspaceInUse as m, WORKSPACE_OUTPUT_DIRS as n, deleteOrphanedWorkspaces as o, withIdleWorkspace as p, clearWorkspaceOutputs as r, isInsideWorkspaces as s, REBUILD_COST as t, sizeText as u, stopTunnel as v, runningBundleInstancesAsync as w, withManagedRemoteWorktreeRemovalLock as x, terminateChild as y, releaseBuildSlot as z };
+export { tapBuildLog as $, runningBundleInstancesAsync as A, mapLimited as At, workspaceBuildInProgress as B, stopTunnel as C, buildSlotUsage as Ct, withManagedTunnelLock as D, createGcResults as Dt, withManagedRemoteWorktreeRemovalLock as E, GC_OUTPUT as Et, collectOwnedDeviceActivityAsync as F, buildStatusLine as G, NO_BUILD_PROGRESS as H, idleDeviceLines as I, parseActiveBuild as J, bundlingActivity as K, idleShutdownCandidates as L, collectIdleDevices as M, sizeConcurrency as Mt, collectIdleDevicesAsync as N, withManagedTunnelRemovalLock as O, takeGcResults as Ot, collectOwnedDeviceActivity as P, startBuildProgress as Q, parseIdleDuration as R, startTunnelSequence as S, acquireBuildSlot as St, withManagedRemoteWorktreeLock as T, releaseBuildSlot as Tt, activeBuildState as U, ACTIVE_BUILD_KEY as V, buildReport as W, recordFinishedBuild as X, recordBuildPhase as Y, runFailureRecord as Z, emptyWorkspaceDir as _, teardownParkedIosSim as _t, collectOrphanedWorkspaces as a, readStats$1 as at, workspaceInUseAsync as b, measureDu as bt, isInsideWorkspaces as c, recordRunStats as ct, recentNativeUseReason as d, eraseParkedIosSim as dt, thrownRunFailureRecord as et, rootPresence as f, teardownBrowserHeld as ft, ARTIFACT_DIRS as g, teardownParkedAvd as gt, workspaceDirRemoved as h, teardownOwnedIosSim as ht, clearWorkspaceOutputs as i, readRunEstimates as it, runningInstancesInAsync as j, readConcurrency as jt, hostedBundleDirs as k, eachLimited as kt, keptByLock as l, statsProjectKey$1 as lt, workspaceBuildReasons as m, teardownOwnedBrowser as mt, REBUILD_COST as n, STIM_VERSION as nt, collectWorkspaceOutputs as o, recordCapacityRefusal as ot, sizeText as p, teardownOwnedAvd as pt, estimateBuild as q, WORKSPACE_OUTPUT_DIRS as r, createRunRecorder as rt, deleteOrphanedWorkspaces as s, recordCapacityWait as st, LIGHTEN_AFTER_MS as t, errorRemedy as tt, listWorkspaceDirs as u, eraseParkedAvd as ut, withIdleWorkspace as v, probePublicHttp as vt, terminateChild as w, listBuildSlots as wt, resolveSupervisorTarget as x, writeUsageCache as xt, workspaceInUse as y, canonical$1 as yt, shutDownIdleDevices as z };