stim 1.17.2 → 1.19.0

package/dist/{budget-DfcgFdQB.mjs → budget-Dz-kyXLv.mjs}

@@ -1,38 +1,33 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { A as directorySize, D as withConfigLock$1, F as volumeRootFor, H as projectDeviceSlots, M as isOnMountedVolume, P as measuredDirectorySize, _ as loadConfig$1, a as clearDevice, d as getConfigDir, j as formatBytes, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { i as registeredCaches } from "./cache-manifest-DnUHBJaU.mjs";
-import { l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-CDAIFD-8.mjs";
-import { l as resolveProjectMetro, r as killMetroTree } from "./metro-g8NqiJp-.mjs";
-import { d as sharedBuildCache, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { a as capacity, l as environmentState, u as formatSpace } from "./status-CzS4bPO9.mjs";
-import { i as recordGcResult, n as withIdleWorkspace, o as canonicalPath } from "./in-use-CvGOUn-x.mjs";
-import { i as createDeviceProcessTables, p as workspaceActivity } from "./activity-IRvJY_ru.mjs";
-import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-DpoS36_u.mjs";
-import { n as listBuildSlots } from "./build-slots-41v_d2x9.mjs";
-import { l as readPidFile, s as clearWorkspaceSupervisor } from "./state-BKa8wNN5.mjs";
-import { a as parseWatchmanPid, i as parseWatchmanClients, n as parseTriggerCount, r as parseWatchRoots, t as parseSubscriberNames } from "./watchman-APYjXSQa.mjs";
-import { A as listAvds, I as ownedAvdDirectory, at as isStimOwnedSim, ct as dropParked, it as isStimOwnedAvd, pt as readParked, z as ownedAvdSerialResolver } from "./android-B_YNZy61.mjs";
-import { _ as parseRuntimeVersion, f as listIosDeviceTypes, u as listAllIosSims } from "./ios-DSfnPfse.mjs";
-import { _ as teardownParkedAvd, d as eraseParkedAvd, f as eraseParkedIosSim, g as teardownOwnedIosSim, m as teardownOwnedAvd, t as resolveSupervisorTarget, v as teardownParkedIosSim } from "./ownership-BMLqyBgJ.mjs";
-import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-import { i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices } from "./idle-BXG__1BA.mjs";
-import { a as collectWorkspaceOutputs, r as clearWorkspaceOutputs } from "./workspaces-Bcib97-6.mjs";
-import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-rhmGfwvt.mjs";
-import { existsSync, readFileSync, statSync, statfsSync } from "node:fs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { a as formatElapsed, l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-Bt8ygHE7.mjs";
+import { A as directorySize, D as withConfigLock$1, F as volumeRootFor, H as projectDeviceSlots, M as isOnMountedVolume, P as measuredDirectorySize, _ as loadConfig$1, a as clearDevice, d as getConfigDir, j as formatBytes, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
+import { a as updateWorkspaceState, c as writeWorkspaceState, d as sharedBuildCache, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { D as readPidFile, T as clearWorkspaceSupervisor } from "./project-B5eQ1USs.mjs";
+import { r as killMetroTree, u as resolveProjectMetro } from "./metro-DI2AjPF_.mjs";
+import { a as parseWatchmanPid, d as capacity, g as formatSpace, h as environmentState, i as parseWatchmanClients, n as parseTriggerCount, r as parseWatchRoots, t as parseSubscriberNames } from "./watchman-BL1IdOtq.mjs";
+import { i as registeredCaches } from "./cache-manifest-DiwKSyv9.mjs";
+import { A as teardownParkedAvd, D as teardownOwnedAvd, F as recordGcResult, L as canonicalPath, N as listBuildSlots, T as eraseParkedIosSim, a as collectWorkspaceOutputs, f as withIdleWorkspace, j as teardownParkedIosSim, k as teardownOwnedIosSim, m as resolveSupervisorTarget, r as clearWorkspaceOutputs, w as eraseParkedAvd } from "./workspaces-Djb2gfi9.mjs";
+import { i as createDeviceProcessTables, o as idleForMs, p as workspaceActivity, r as createActivityReader } from "./activity-BSw0x84R.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-Cu7PtQpZ.mjs";
+import { A as listAvds, I as ownedAvdDirectory, at as isStimOwnedSim, ct as dropParked, it as isStimOwnedAvd, pt as readParked, z as ownedAvdSerialResolver } from "./android-BdQC6zs1.mjs";
+import { d as listAllIosSims, p as listIosDeviceTypes, v as parseRuntimeVersion } from "./ios-BWbHFZVz.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-B4iWH4E-.mjs";
+import { c as supervisorError } from "./metro-store-BAHFcJm6.mjs";
+import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, statfsSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
-import { homedir, tmpdir } from "os";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { METRO_NAMED_CACHE_LAYOUT, compiledHelper, configDir } from "@stim-cli/core";
-import { MACHINE_OWNER_KINDS, buildWorkerRoot, loadConfig, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, DEV_SERVER_STOP_REQUEST_KEY, LAST_BUILD_KEYS, MACHINE_OWNER_KINDS, STATS_VERSION, buildWorkerRoot, decodeStats, isJsonObject, loadConfig, parseMissReason, readDevServerStop, readDevServerStopRequest, readRunEstimates, readStats as readStats$1, settingDefinition, settingValueError, statsFile, statsProjectKey as statsProjectKey$1, trimCapacityRefusals, trimCapacityWaits, trimSamples, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
-import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
+import { homedir, platform, totalmem } from "node:os";
 import chalk from "chalk";
+import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, compiledHelper, configDir } from "@stim-cli/core";
+import { homedir as homedir$1, tmpdir as tmpdir$1 } from "os";
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot() {
-	return join$1(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+	return join$1(homedir$1(), "Library", "Developer", "Xcode", "DerivedData");
 }
 function compilationCache() {
 	const dir = join$1(xcodeDerivedDataRoot(), "CompilationCache.noindex");
@@ -45,7 +40,7 @@ function compilationCache() {
 	};
 }
 function gradleBuildCache() {
-	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir(), ".gradle");
+	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir$1(), ".gradle");
 	const dir = resolve$1(gradleHome, "caches", "build-cache-1");
 	if (!existsSync$1(dir)) return null;
 	return {
@@ -56,7 +51,7 @@ function gradleBuildCache() {
 	};
 }
 function metroFileMaps() {
-	const root = tmpdir();
+	const root = tmpdir$1();
 	if (!existsSync$1(root)) return null;
 	let names;
 	try {
@@ -201,7 +196,7 @@ function canonicalCacheDir(dir) {
 function sizeCaches(caches) {
 	return caches.map((c) => Object.assign({}, c, { bytes: c.bytes ?? directorySize(c.dir) }));
 }
-function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
+function pruneCache(cache, { olderThanDays, now = Date.now(), protect, evictBytes, byMtime = false } = {}) {
 	const cutoff = now - olderThanDays * 24 * 60 * 60 * 1e3;
 	if (cache.prune === "report-only") return {
 		removed: 0,
@@ -214,27 +209,38 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		skipped: "index-backed; empty it whole or not at all"
 	};
 	const entries = cache.files ?? entriesAtDepth(cache.dir, cache.entriesDepth ?? 1);
+	const candidates = [];
+	let protectedEntries = 0;
+	for (const entry of entries) try {
+		const st = statSync$1(entry);
+		const used = byMtime ? st.mtimeMs : Math.max(st.atimeMs, st.mtimeMs);
+		if (used >= cutoff) continue;
+		if (protect?.(entry)) {
+			protectedEntries++;
+			continue;
+		}
+		candidates.push({
+			entry,
+			used,
+			isDirectory: st.isDirectory(),
+			size: st.size
+		});
+	} catch {}
+	if (evictBytes !== void 0) candidates.sort((a, b) => a.used - b.used);
 	let removed = 0;
 	let bytes = 0;
 	let failed = 0;
-	for (const entry of entries) {
-		let used;
-		let size;
-		try {
-			const st = statSync$1(entry);
-			used = Math.max(st.atimeMs, st.mtimeMs);
-			size = st.isDirectory() ? directorySize(entry) : st.size;
-		} catch {
-			continue;
-		}
-		if (used >= cutoff) continue;
+	for (const { entry, isDirectory, size } of candidates) {
+		if (evictBytes !== void 0 && bytes >= evictBytes) break;
 		try {
+			if (!existsSync$1(entry) || statSync$1(entry).mtimeMs >= cutoff) continue;
+			const entryBytes = isDirectory ? directorySize(entry) : size;
 			rmSync$1(entry, {
 				recursive: true,
 				force: true
 			});
 			removed++;
-			bytes += size;
+			bytes += entryBytes;
 		} catch {
 			failed++;
 		}
@@ -243,7 +249,8 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		removed,
 		bytes,
 		failed,
-		skipped: null
+		skipped: null,
+		protectedEntries
 	};
 }
 function entriesAtDepth(dir, depth) {
@@ -1524,8 +1531,8 @@ function ownsItsDirectory(cache) {
 	const dir = canonicalPath(cache.dir);
 	if (dirname$1(dir) === dir) return false;
 	return ![
-		homedir(),
-		tmpdir(),
+		homedir$1(),
+		tmpdir$1(),
 		getConfigDir()
 	].map(canonicalPath).includes(dir);
 }
@@ -2112,6 +2119,1322 @@ function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords)
 	return deleteFailures;
 }
 //#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(run.durationMs);
+	const phases = {
+		coldBuildMs: wholeMs(run.coldBuildMs),
+		podsMs: wholeMs(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(placement.decision === "offloaded" ? placement.buildMs : run.coldBuildMs);
+	const localEstimateMs = wholeMs(before?.lastColdBuildMs);
+	const slotWaitMs = wholeMs(placement.slotWaitMs);
+	const deviceSlotWaitMs = wholeMs(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(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(ms);
+		},
+		setPodsMs(ms) {
+			podsMs = wholeMs(ms);
+		},
+		addDeviceSlotWaitMs(ms) {
+			deviceSlotWaitMs += wholeMs(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(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/engine/build-progress.ts
+const ACTIVE_BUILD_KEY = "activeBuild";
+const NO_BUILD_PROGRESS = {
+	step: () => {},
+	estimate: () => {},
+	miss: () => {},
+	hit: () => {},
+	deviceSetup: () => {},
+	deviceSetupKnown: () => void 0,
+	place: () => {},
+	waitingOn: () => {},
+	waitingFor: () => {},
+	output: () => {},
+	durations: () => ({}),
+	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;
+		}
+	};
+}
+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, 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
+		}
+	};
+	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);
+	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
+			});
+			if (phase !== "wait") delete record.waitingOn;
+			const outcome = record.outcome || platform === "macos" ? null : settledOutcome(phase, record.phases);
+			if (outcome) settle(outcome);
+			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) {
+				if (!current) return;
+				delete record.placement;
+				return write();
+			}
+			if (current?.host === remote.host && current.phase === remote.phase) return;
+			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();
+		},
+		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());
+		},
+		steps() {
+			const detail = parser.detail("");
+			return detail?.unit === "steps" ? detail.total : null;
+		},
+		clear() {
+			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);
+			});
+		}
+	};
+}
+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, record, { update = updateWorkspaceState, now = Date.now } = {}) {
+	const platform = record.platform;
+	update(root, (state) => {
+		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+		const own = active?.platform === platform ? active : null;
+		const entry = {
+			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
+			result: finishedResult(record),
+			slot: own?.slot ?? "default",
+			phases: own ? phaseDurations(own.phases, now()) : {}
+		};
+		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 (platform !== "macos" && (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
+					}
+				}
+			};
+		}
+		if (platform === "macos") return withHistoryEntry(state, platform, entry);
+		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 = left.platform === "macos" ? state[BUILD_HISTORY_KEY]?.macos?.[0] : state[LAST_BUILD_KEYS[left.platform]];
+	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);
+	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 } : {},
+		...waitingOn ? { waitingOn } : {},
+		...waitingFor ? { waitingFor } : {},
+		...typeof record.deviceSetup === "boolean" ? { deviceSetup: record.deviceSetup } : {},
+		...record.outcome === "hit" || record.outcome === "cold" ? { outcome: record.outcome } : {},
+		...estimate ? { estimate } : {},
+		claim: {
+			root: claim.root,
+			path: typeof claim.path === "string" ? claim.path : "",
+			claimId: claim.claimId,
+			pid: typeof claim.pid === "number" ? claim.pid : 0
+		}
+	};
+}
+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 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 } : {}
+	};
+}
+function remainingText(remainingMs) {
+	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
+}
+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 head = `build: ${report.platform}${slot} ${report.phase}${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 findOwnedDeviceActivity(inputs).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) {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return {
+		config,
+		sims,
+		readActivity: createActivityReader({ now }),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
+	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
+}
+function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
+	return findIdleDevices({
+		...deviceActivityInputs(config, sims, now),
+		deadProjects,
+		now,
+		buildInProgress: workspaceBuildInProgress
+	});
+}
+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}`;
+	})];
+}
+function shutDownIdleDevices(devices, idleMs, recollect) {
+	const candidates = idleShutdownCandidates(devices, idleMs);
+	const shutDown = [];
+	if (candidates.length === 0) {
+		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
+		return {
+			failures: 0,
+			shutDown
+		};
+	}
+	const fresh = idleShutdownCandidates(recollect(), idleMs);
+	let failures = 0;
+	for (const device of candidates) {
+		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) {
+			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
+			recordGcResult("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: `it is no longer idle for ${formatLongDuration(idleMs)}`
+			});
+			continue;
+		}
+		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
+			projectPath: device.project,
+			slot: device.slot
+		} });
+		if (outcome.status === "torn-down") {
+			shutDown.push(device);
+			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
+			recordGcResult("idleDevice", "done", device.name, {
+				id: device.id,
+				detail: `idle ${formatLongDuration(current.idleForMs)}`
+			});
+		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
+		else if (outcome.status === "skipped") {
+			console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
+			recordGcResult("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		} else {
+			failures++;
+			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
+			recordGcResult("idleDevice", "failed", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		}
+	}
+	return {
+		failures,
+		shutDown
+	};
+}
+//#endregion
+//#region src/supervisor/stop-cause.ts
+function requestDevServerStop(root, processToken, requester) {
+	if (!processToken) return;
+	try {
+		writeWorkspaceState(root, { [DEV_SERVER_STOP_REQUEST_KEY]: {
+			processToken,
+			by: requester.by,
+			pid: process.pid,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			...requester.workspace ? { workspace: requester.workspace } : {}
+		} });
+	} catch {}
+}
+function withdrawDevServerStopRequest(root, processToken) {
+	if (!processToken) return;
+	try {
+		clearWorkspaceStateKey(root, DEV_SERVER_STOP_REQUEST_KEY, (value) => {
+			return readDevServerStopRequest({ [DEV_SERVER_STOP_REQUEST_KEY]: value })?.processToken === processToken;
+		});
+	} catch {}
+}
+function devServerStopRecord(trigger, request, at) {
+	if (request) return {
+		reason: "requested",
+		at,
+		by: request.by,
+		byPid: request.pid,
+		...request.workspace ? { byWorkspace: request.workspace } : {}
+	};
+	return trigger.kind === "signal" ? {
+		reason: "signal",
+		at,
+		signal: trigger.signal
+	} : {
+		reason: "server-exited",
+		at,
+		mode: trigger.mode,
+		code: trigger.code,
+		signal: trigger.signal
+	};
+}
+function describeDevServerStop(record) {
+	if (record.reason === "idle") return `idle for ${record.idleMinutes} minutes (metro.idleStopMinutes)`;
+	if (record.reason === "requested") return `stop requested by ${record.by} (pid ${record.byPid}${record.byWorkspace ? ` in ${record.byWorkspace}` : ""})`;
+	if (record.reason === "signal") return `received ${record.signal} with no Stim stop request recorded, so it likely came from outside Stim`;
+	const detail = record.signal ? `signal ${record.signal}` : `exit code ${record.code ?? "unknown"}`;
+	const expoSignal = record.mode === "expo-child" && record.code === 0 ? "; Expo CLI also exits 0 on SIGTERM, and no Stim stop request was recorded" : "";
+	return `the ${record.mode} dev server exited unexpectedly (${detail})${expoSignal}`;
+}
+function devServerStopLevel(record) {
+	if (record.reason === "server-exited") return "error";
+	return record.reason === "signal" ? "warn" : "info";
+}
+/** The log line for a recorded supervisor whose process is proven gone, or null while it may still run. */
+function vanishedSupervisorMessage(record) {
+	if (!record || typeof record.pid !== "number") return null;
+	const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
+	if (identity !== "gone" && identity !== "different") return null;
+	const started = typeof record.startedAt === "string" ? ` (started ${record.startedAt})` : "";
+	return `supervisor pid ${record.pid}${started} ${VANISHED}`;
+}
+const VANISHED = "is gone and recorded no cause: usually SIGKILL, a crash or a machine restart";
+function logVanishedSupervisor(root, record) {
+	const msg = vanishedSupervisorMessage(record);
+	if (!msg) return;
+	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	writer.write({
+		src: "metro",
+		level: "warn",
+		event: "supervisor_vanished",
+		msg
+	});
+	writer.close();
+}
+/** The recorded stop, else a vanished supervisor when status proved the recorded one gone. */
+function metroLastStop(state, supervisor) {
+	const recorded = readDevServerStop(state);
+	if (recorded) return recorded;
+	if (supervisor?.status !== "stale" || typeof supervisor.pid !== "number") return null;
+	const startedAt = typeof supervisor.startedAt === "string" ? supervisor.startedAt : null;
+	return {
+		reason: "vanished",
+		pid: supervisor.pid,
+		startedAt
+	};
+}
+function describeMetroLastStop(stop) {
+	return stop.reason === "vanished" ? `supervisor pid ${stop.pid} ${VANISHED}` : describeDevServerStop(stop);
+}
+//#endregion
 //#region src/supervisor/cache-reset.ts
 async function stopOwnedMetro(root, requester) {
 	const project = getProject(root);
@@ -2163,7 +3486,6 @@ async function stopOwnedMetroForReset(root) {
 const MB = 1048576;
 const GB_IN_MB = 1024;
 const COMMITTED_MEMORY_SHARE = .6;
-const STALE_CACHE_DAYS = 14;
 const DEVICE_LIST_TIMEOUT_MS = 1e4;
 const USAGE_TIMEOUT_MS = 1e4;
 const BUDGET_SETTING_REMEDY = "Fix the value with `stim settings set <key> <value>`, or unset the environment variable. Run `stim guide settings` for the budget keys.";
@@ -2207,7 +3529,7 @@ function machineNumber(key, config, env) {
 		error: null
 	};
 }
-function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem$1() / MB } = {}) {
+function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem() / MB } = {}) {
 	const minFree = machineNumber("budget.minFreeDiskGb", config, env);
 	const hardFloor = machineNumber("budget.hardFloorDiskGb", config, env);
 	const memory = machineNumber("budget.maxCommittedMemoryGb", config, env);
@@ -2280,6 +3602,13 @@ function listSims() {
 		return null;
 	}
 }
+function snapshotSims(snapshot) {
+	try {
+		return snapshot.read().filter((sim) => sim.available);
+	} catch {
+		return null;
+	}
+}
 function runningSupervisorPid(path, project) {
 	const target = resolveSupervisorTarget({
 		state: readWorkspaceState$1(path)?.supervisor,
@@ -2288,11 +3617,11 @@ function runningSupervisorPid(path, project) {
 	});
 	return target.status === "ours" ? target.pid ?? null : null;
 }
-function readMemoryUse() {
+function readMemoryUse(simSnapshot) {
 	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
 	return estimateMemoryUse({
 		config: loadConfig$1(),
-		sims: listSims(),
+		sims: simSnapshot ? snapshotSims(simSnapshot) : listSims(),
 		androidSerial: (avdName) => {
 			try {
 				return resolve(avdName).serial ?? null;
@@ -2475,14 +3804,17 @@ async function reclaimWorkspaceOutputs({ root, dryRun, now, diskRecovered }) {
 function cacheLabel(cache) {
 	return `${cache.name} ${cache.dir}`;
 }
+function trimmableCaches() {
+	return planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+}
 function reclaimStaleCacheEntries({ dryRun }) {
-	const caches = planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+	const caches = trimmableCaches();
 	if (dryRun) return {
 		targets: caches.map(cacheLabel),
 		failures: 0
 	};
 	return {
-		targets: trimCaches(caches, STALE_CACHE_DAYS).map(cacheLabel),
+		targets: trimCaches(caches, 14).map(cacheLabel),
 		failures: 0
 	};
 }
@@ -2496,7 +3828,7 @@ const STEP_ACTIONS = {
 	"idle-devices": "shut down idle owned devices",
 	"idle-dev-servers": "stop idle dev servers",
 	"workspace-outputs": "clear build outputs of idle workspaces",
-	"stale-cache-entries": `trim cache entries unused for ${STALE_CACHE_DAYS} days`
+	"stale-cache-entries": `trim cache entries unused for 14 days`
 };
 async function runStep(step, context) {
 	const log = console.log;
@@ -2520,7 +3852,7 @@ async function runStep(step, context) {
 	}
 }
 function spaceUsers() {
-	const home = homedir$1();
+	const home = homedir();
 	const candidates = [
 		["Stim state", getConfigDir()],
 		["shared build cache", sharedBuildCache()],
@@ -2558,7 +3890,7 @@ function describeShortfall(budget, measure, short) {
 		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} active workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
 	];
 }
-async function enforceBudget({ root, note, dryRun = false, budget: resolved }, overrides = {}) {
+async function enforceBudget({ root, note, dryRun = false, budget: resolved, simSnapshot }, overrides = {}) {
 	const deps = {
 		...DEFAULT_DEPS,
 		...overrides
@@ -2579,7 +3911,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved }, o
 	const paths = [root, getConfigDir()];
 	const measureNow = () => ({
 		volumes: budget.minFreeDiskMb > 0 || budget.hardFloorDiskMb > 0 ? deps.volumes(paths) : [],
-		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory() : null
+		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory(simSnapshot) : null
 	});
 	let measure = measureNow();
 	let short = budgetShortfalls(budget, measure);
@@ -2600,6 +3932,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved }, o
 			}).disk.length === 0
 		});
 		if (!dryRun) {
+			simSnapshot?.invalidate();
 			measure = measureNow();
 			short = budgetShortfalls(budget, measure);
 		}
@@ -2734,4 +4067,4 @@ function budgetLine(report) {
 	return `${report.volumes.length ? `${report.volumes.map((v) => `${v.freeGb} GB free on ${v.volume}`).join(", ")} (reclaims below ${Math.max(budget.minFreeDiskGb, budget.hardFloorDiskGb)} GB, ${budget.hardFloorDiskGb ? `refuses below ${budget.hardFloorDiskGb} GB` : "never refuses"})` : "disk budget off"}; ${report.memory ? `roughly ${report.memory.committedGb} GB of a ${budget.maxCommittedMemoryGb} GB memory budget committed` : "memory budget off"}`;
 }
 //#endregion
-export { sizeCaches as $, includesWorkspaceOutputs as A, collectMemoryReport as B, findStaleProjectDevices as C, includesArchives as D, emptyCaches as E, selectsBeyondCaches as F, memorySweepIsScoped as G, memoryCacheKind as H, trimCaches as I, scopedMemoryReport as J, memoryWorkPending as K, parseArchiveSelector as L, planCacheEmptying as M, previewScopedEmptying as N, includesParkedDevices as O, selectCaches as P, discoverCaches as Q, GRADLE_DAEMONS_KIND as R, findStaleDeviceRecords as S, withAndroidAvdSizes as T, memoryLines as U, inspectWatchmanMemory as V, memoryScope as W, attributeMachineUsage as X, phase as Y, readFootprints as Z, describeParkedSims as _, machineNumber as a, eraseParkedDevices as b, resolveBudget as c, collectDeviceLeases as d, collectParkedAvds as f, deleteProjectDevices as g, deleteParkedSims as h, inspectBudget as i, isWorkspacesScope as j, includesRecordings as k, stopOwnedMetroForReset as l, deleteParkedAvds as m, budgetLine as n, peekBudget as o, collectParkedSims as p, reclaimMemory as q, enforceBudget as r, readVolumeSpace as s, budgetGate as t, DEVICE_LIST_TIMEOUT_MS$1 as u, describeUnverifiableDevices as v, unverifiedDeviceCommand as w, findOrphanedDevices as x, deviceSweepIsScoped as y, WATCHMAN_KIND as z };
+export { describeUnverifiableDevices as $, buildReport as A, phase as At, readStats$1 as B, idleDeviceLines as C, memoryCacheKind as Ct, ACTIVE_BUILD_KEY as D, memoryWorkPending as Dt, workspaceBuildInProgress as E, memorySweepIsScoped as Et, recordFinishedBuild as F, sizeCaches as Ft, DEVICE_LIST_TIMEOUT_MS$1 as G, recordCapacityWait as H, startBuildProgress as I, collectParkedSims as J, collectDeviceLeases as K, tapBuildLog as L, estimateBuild as M, readFootprints as Mt, parseActiveBuild as N, discoverCaches as Nt, NO_BUILD_PROGRESS as O, reclaimMemory as Ot, recordBuildPhase as P, pruneCache as Pt, describeParkedSims as Q, createRunRecorder as R, collectOwnedDeviceActivity as S, inspectWatchmanMemory as St, shutDownIdleDevices as T, memoryScope as Tt, recordRunStats as U, recordCapacityRefusal as V, statsProjectKey$1 as W, deleteParkedSims as X, deleteParkedAvds as Y, deleteProjectDevices as Z, metroLastStop as _, trimCaches as _t, inspectBudget as a, unverifiedDeviceCommand as at, withdrawDevServerStopRequest as b, WATCHMAN_KIND as bt, readVolumeSpace as c, includesArchives as ct, stopOwnedMetroForReset as d, includesWorkspaceOutputs as dt, deviceSweepIsScoped as et, describeDevServerStop as f, isWorkspacesScope as ft, logVanishedSupervisor as g, selectsBeyondCaches as gt, devServerStopRecord as h, selectCaches as ht, enforceBudget as i, findStaleProjectDevices as it, buildStatusLine as j, attributeMachineUsage as jt, activeBuildState as k, scopedMemoryReport as kt, resolveBudget as l, includesParkedDevices as lt, devServerStopLevel as m, previewScopedEmptying as mt, budgetLine as n, findOrphanedDevices as nt, machineNumber as o, withAndroidAvdSizes as ot, describeMetroLastStop as p, planCacheEmptying as pt, collectParkedAvds as q, cacheLabel as r, findStaleDeviceRecords as rt, peekBudget as s, emptyCaches as st, budgetGate as t, eraseParkedDevices as tt, trimmableCaches as u, includesRecordings as ut, requestDevServerStop as v, parseArchiveSelector as vt, parseIdleDuration as w, memoryLines as wt, collectIdleDevices as x, collectMemoryReport as xt, vanishedSupervisorMessage as y, GRADLE_DAEMONS_KIND as yt, readRunEstimates as z };