stim 1.11.0 → 1.12.0

package/dist/{workspaces-COD2xCz-.mjs → budget-DbzW5VTD.mjs}

@@ -1,25 +1,78 @@
-import { A as directorySize, H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, T as withConfigLock$1, f as getProject, g as loadConfig$1, h as isPathPrefix, i as clearDevice, j as formatBytes, u as getConfigDir, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
-import { i as registeredCaches } from "./cache-manifest-Pubfp8wV.mjs";
-import { M as workspaceName$1, v as workspaceLastUsed } from "./metro-BWLOJ_Wr.mjs";
-import { u as plural } from "./command-output-D5z2_bcF.mjs";
-import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-D83nqeMX.mjs";
-import { D as listAvds, N as ownedAvdDirectory, Y as isStimOwnedSim, w as isStimOwnedAvdName } from "./android-C4zG2Tuc.mjs";
-import { _ as dropParked, b as readParked, d as teardownOwnedAvd, f as teardownOwnedIosSim, m as teardownParkedIosSim, p as teardownParkedAvd } from "./ownership-BiojdtAp.mjs";
-import { d as listIosDeviceTypes, g as parseRuntimeVersion, l as listAllIosSims } from "./ios-DArbmwer.mjs";
-import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-DVhlSoyn.mjs";
-import { existsSync, lstatSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
+import { B as deviceSlotPlatforms, E as withConfigLock$1, F as measuredDirectorySize, I as volumeRootFor, M as formatBytes, N as isOnMountedVolume, O as process_identity_exports, P as listMountedVolumes, U as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as directorySize, o as clearSupervisor, p as getProject } from "./config-0jCcMM0E.mjs";
+import { i as registeredCaches } from "./cache-manifest-DWPF4RKJ.mjs";
+import { M as workspaceName$1, O as workspaceDir, S as sharedBuildCache, m as readWorkspaceState$1, s as resolveProjectMetro, t as killMetroTree, v as workspaceLastUsed } from "./metro-Dzo30hvJ.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { s as clearWorkspaceSupervisor } from "./state-DcDgzfu3.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BvvJTfo_.mjs";
+import { l as phaseLine, u as plural } from "./command-output-BWCj5Vh-.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-B9LAXIUH.mjs";
+import { a as workspaceActivity } from "./activity-CCZJs__P.mjs";
+import { L as ownedAvdSerialResolver, O as listAvds, P as ownedAvdDirectory, Q as isStimOwnedSim, T as isStimOwnedAvdName } from "./android-75Sk2rIR.mjs";
+import { _ as dropParked, b as readParked, d as teardownOwnedAvd, f as teardownOwnedIosSim, m as teardownParkedIosSim, p as teardownParkedAvd, t as resolveSupervisorTarget } from "./ownership-B8d4kXBx.mjs";
+import { d as listIosDeviceTypes, g as parseRuntimeVersion, l as listAllIosSims } from "./ios-CZWOHTTc.mjs";
+import { i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices } from "./idle-S3tFZ53_.mjs";
+import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-D9XYEgFD.mjs";
+import { c as formatSpace, r as capacity, s as environmentState } from "./status-BUASYyy_.mjs";
+import { existsSync, statSync, statfsSync } from "node:fs";
+import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
 import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
-import { isJsonObject, readJsonFile } from "@stim-cli/core/state";
+import { isJsonObject, readJsonFile, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { dirname as dirname$1, join as join$1, sep as sep$1 } from "node:path";
 import { homedir, tmpdir } from "os";
+import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
 import chalk from "chalk";
+//#region src/supervisor/cache-reset.ts
+async function stopOwnedMetro(root) {
+	const project = getProject(root);
+	const port = project?.metroPort;
+	const target = resolveSupervisorTarget({
+		state: readWorkspaceState$1(root)?.supervisor,
+		record: project?.supervisor,
+		reservedPort: port
+	});
+	if (target.status === "unverified") return {
+		status: "unverified",
+		reason: target.reason ?? "unknown identity"
+	};
+	if (port && target.status !== "ours" && !(await resolveProjectMetro(port, root)).missing) return {
+		status: "external",
+		reason: `a dev server Stim did not start answers on port ${port}`
+	};
+	if (target.status !== "ours") return { status: "not-running" };
+	const expected = {
+		pid: target.pid,
+		processToken: target.processToken
+	};
+	if (!killMetroTree(target.pid, target.processToken) || !await (0, process_identity_exports.waitForProcessExit)(expected, 1e4)) return {
+		status: "stuck",
+		reason: `supervisor pid ${target.pid} did not exit`
+	};
+	if (port && !(await resolveProjectMetro(port, root)).missing) return {
+		status: "port-occupied",
+		reason: `port ${port} is still occupied after stopping Metro`
+	};
+	clearWorkspaceSupervisor(root, expected);
+	clearSupervisor(root, expected);
+	return { status: "stopped" };
+}
+async function stopOwnedMetroForReset(root) {
+	const stopped = await stopOwnedMetro(root);
+	switch (stopped.status) {
+		case "unverified": throw supervisorError("STIM_SUPERVISOR_EXITED", `Cannot reset Metro: ${stopped.reason}.`, "Stop it with the tool that started it, then retry. Stim leaves unverified processes alone.");
+		case "external": throw supervisorError("STIM_SUPERVISOR_EXITED", "Cannot reset an externally started dev server.", "Stop it with the tool that started it, then retry `stim start --reset-cache`.");
+		case "stuck": throw supervisorError("STIM_SUPERVISOR_EXITED", "The owned Metro supervisor could not be stopped for a cache reset.", "Inspect `stim status` and `stim logs`, then retry. No cache reset was recorded.");
+		case "port-occupied": throw supervisorError("STIM_SUPERVISOR_EXITED", `Port ${getProject(root)?.metroPort} is still occupied after stopping Metro.`, "Inspect the listener before retrying. Stim does not terminate unrecorded processes.");
+	}
+}
+//#endregion
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot() {
 	return join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
 }
 function compilationCache() {
 	const dir = join(xcodeDerivedDataRoot(), "CompilationCache.noindex");
-	if (!existsSync(dir)) return null;
+	if (!existsSync$1(dir)) return null;
 	return {
 		name: "Xcode compilation cache",
 		dir,
@@ -30,7 +83,7 @@ function compilationCache() {
 function gradleBuildCache() {
 	const gradleHome = process.env.GRADLE_USER_HOME || join(homedir(), ".gradle");
 	const dir = resolve(gradleHome, "caches", "build-cache-1");
-	if (!existsSync(dir)) return null;
+	if (!existsSync$1(dir)) return null;
 	return {
 		name: "Gradle build cache",
 		dir,
@@ -40,10 +93,10 @@ function gradleBuildCache() {
 }
 function metroFileMaps() {
 	const root = tmpdir();
-	if (!existsSync(root)) return null;
+	if (!existsSync$1(root)) return null;
 	let names;
 	try {
-		names = readdirSync(root).filter((n) => n.startsWith("metro-file-map-"));
+		names = readdirSync$1(root).filter((n) => n.startsWith("metro-file-map-"));
 	} catch {
 		return null;
 	}
@@ -51,7 +104,7 @@ function metroFileMaps() {
 	const files = [];
 	let bytes = 0;
 	for (const n of names) try {
-		const st = statSync(join(root, n));
+		const st = statSync$1(join(root, n));
 		if (uid !== void 0 && st.uid !== uid) continue;
 		files.push(join(root, n));
 		bytes += st.size;
@@ -168,7 +221,7 @@ function cachePathContains(parent, child) {
 }
 function canonicalCacheDir(dir) {
 	try {
-		return realpathSync(dir);
+		return realpathSync$1(dir);
 	} catch {
 		return resolve(dir);
 	}
@@ -196,7 +249,7 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		let used;
 		let size;
 		try {
-			const st = statSync(entry);
+			const st = statSync$1(entry);
 			used = Math.max(st.atimeMs, st.mtimeMs);
 			size = st.isDirectory() ? directorySize(entry) : st.size;
 		} catch {
@@ -204,7 +257,7 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		}
 		if (used >= cutoff) continue;
 		try {
-			rmSync(entry, {
+			rmSync$1(entry, {
 				recursive: true,
 				force: true
 			});
@@ -228,7 +281,7 @@ function entriesAtDepth(dir, depth) {
 		for (const parent of level) {
 			let names;
 			try {
-				names = readdirSync(parent);
+				names = readdirSync$1(parent);
 			} catch {
 				continue;
 			}
@@ -313,7 +366,7 @@ function emptyCache(cache) {
 	});
 	let names;
 	try {
-		names = readdirSync(cache.dir);
+		names = readdirSync$1(cache.dir);
 	} catch (e) {
 		return {
 			removed: 0,
@@ -324,7 +377,7 @@ function emptyCache(cache) {
 	let removed = 0;
 	let failed = 0;
 	for (const name of names) try {
-		rmSync(join(cache.dir, name), {
+		rmSync$1(join(cache.dir, name), {
 			recursive: true,
 			force: true
 		});
@@ -383,7 +436,7 @@ function emptyCaches(caches) {
 }
 //#endregion
 //#region src/commands/gc/devices.ts
-const DEVICE_LIST_TIMEOUT_MS = 3e4;
+const DEVICE_LIST_TIMEOUT_MS$1 = 3e4;
 const AVD_SIZE_TIMEOUT_MS = 5e3;
 const DAY_MS$1 = 864e5;
 function describeKept(ref) {
@@ -579,7 +632,7 @@ function collectParkedSims(deps, age = {}) {
 	let deviceTypes = [];
 	try {
 		sims = (deps.listAllIosSims ?? listAllIosSims)({
-			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+			timeoutMs: DEVICE_LIST_TIMEOUT_MS$1,
 			includeUnavailable: true
 		});
 	} catch {
@@ -690,7 +743,7 @@ function collectDeviceLeases(now) {
 			expired.push(entry);
 			continue;
 		}
-		if (!existsSync(lease.holder)) kept.push({
+		if (!existsSync$1(lease.holder)) kept.push({
 			name: entry.name,
 			path: entry.path,
 			reason: `${lease.holder} is not on this machine, but the lease runs until ${lease.expiresAt}`
@@ -785,7 +838,7 @@ function listWorkspaceDirs() {
 	const root = workspacesRoot();
 	let names;
 	try {
-		names = readdirSync(root).toSorted();
+		names = readdirSync$1(root).toSorted();
 	} catch {
 		return [];
 	}
@@ -793,7 +846,7 @@ function listWorkspaceDirs() {
 	for (const name of names) {
 		const dir = join(root, name);
 		try {
-			if (!statSync(dir).isDirectory()) continue;
+			if (!statSync$1(dir).isDirectory()) continue;
 		} catch {
 			continue;
 		}
@@ -852,7 +905,7 @@ function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse
 }
 function rootPresence(path) {
 	try {
-		lstatSync(path);
+		lstatSync$1(path);
 		return true;
 	} catch (error) {
 		const code = error?.code;
@@ -899,7 +952,7 @@ function sizeOf(dir) {
 	return measuredDirectorySize(dir, { timeoutMs: SIZE_TIMEOUT_MS });
 }
 function outputPaths(dir) {
-	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync(path));
+	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync$1(path));
 }
 function outputBytes(paths) {
 	let total = 0;
@@ -947,7 +1000,7 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
 					now
 				});
 				if (again?.keptReason) return again.keptReason;
-				for (const name of WORKSPACE_OUTPUT_DIRS) rmSync(join(entry.dir, name), {
+				for (const name of WORKSPACE_OUTPUT_DIRS) rmSync$1(join(entry.dir, name), {
 					recursive: true,
 					force: true
 				});
@@ -980,7 +1033,7 @@ function stillOrphaned({ dir, projectRoot }) {
 async function deleteOrphanedWorkspaces(orphaned) {
 	let failures = 0;
 	for (const entry of orphaned) {
-		if (!existsSync(entry.dir)) continue;
+		if (!existsSync$1(entry.dir)) continue;
 		let run;
 		try {
 			run = await withIdleWorkspace(entry.projectRoot, () => {
@@ -1010,4 +1063,560 @@ function sizeText(bytes) {
 	return bytes === null ? "size unknown" : formatBytes(bytes);
 }
 //#endregion
-export { discoverCaches as A, unverifiedDeviceCommand as C, planCacheEmptying as D, includesWorkspaceOutputs as E, selectCaches as O, findStaleProjectDevices as S, emptyCaches as T, describeParkedSims as _, collectWorkspaceOutputs as a, findOrphanedDevices as b, listWorkspaceDirs as c, collectDeviceLeases as d, collectParkedAvds as f, deleteProjectDevices as g, deleteParkedSims as h, collectOrphanedWorkspaces as i, sizeCaches as j, trimCaches as k, sizeText as l, deleteParkedAvds as m, WORKSPACE_OUTPUT_DIRS as n, deleteOrphanedWorkspaces as o, collectParkedSims as p, clearWorkspaceOutputs as r, isInsideWorkspaces as s, REBUILD_COST as t, DEVICE_LIST_TIMEOUT_MS as u, describeUnverifiableDevices as v, withAndroidAvdSizes as w, findStaleDeviceRecords as x, deviceSweepIsScoped as y };
+//#region src/budget.ts
+const MB = 1048576;
+const GB_IN_MB = 1024;
+const COMMITTED_MEMORY_SHARE = .6;
+const STALE_CACHE_DAYS = 14;
+const DEVICE_LIST_TIMEOUT_MS = 1e4;
+const USAGE_TIMEOUT_MS = 1e4;
+const BUDGET_SETTING_REMEDY = "Fix the value with `stim settings set <key> <value>`, or unset the environment variable. Run `stim guide settings` for the budget keys.";
+function valueAt(source, key) {
+	let node = source;
+	for (const part of key.split(".")) {
+		if (node === null || typeof node !== "object" || Array.isArray(node)) return void 0;
+		node = node[part];
+	}
+	return node;
+}
+function machineNumber(key, config, env) {
+	const setting = settingDefinition(key);
+	const fromEnv = setting.env ? env[setting.env] : void 0;
+	if (fromEnv !== void 0 && fromEnv !== "") {
+		const value = fromEnv.trim() === "" ? NaN : Number(fromEnv);
+		const problem = settingValueError(setting, value);
+		return problem ? {
+			value: void 0,
+			error: `Invalid ${setting.env} value ${JSON.stringify(fromEnv)}. Expected ${problem}.`
+		} : {
+			value,
+			error: null
+		};
+	}
+	if (env.STIM_HOME && setting.scopedHomeValue !== void 0) return {
+		value: setting.scopedHomeValue,
+		error: null
+	};
+	const raw = valueAt(config, key);
+	if (raw === void 0) return {
+		value: typeof setting.default === "number" ? setting.default : void 0,
+		error: null
+	};
+	const problem = settingValueError(setting, raw);
+	return problem ? {
+		value: void 0,
+		error: `Invalid ${key} value ${JSON.stringify(raw)}. Expected ${problem}.`
+	} : {
+		value: raw,
+		error: null
+	};
+}
+function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem$1() / MB } = {}) {
+	const minFree = machineNumber("budget.minFreeDiskGb", config, env);
+	const hardFloor = machineNumber("budget.hardFloorDiskGb", config, env);
+	const memory = machineNumber("budget.maxCommittedMemoryGb", config, env);
+	const live = machineNumber("budget.maxLiveWorkspaces", config, env);
+	return {
+		budget: {
+			minFreeDiskMb: (minFree.value ?? 0) * GB_IN_MB,
+			hardFloorDiskMb: (hardFloor.value ?? 0) * GB_IN_MB,
+			maxCommittedMemoryMb: memory.value === void 0 ? Math.round(totalMemoryMb * COMMITTED_MEMORY_SHARE) : memory.value * GB_IN_MB,
+			maxLiveWorkspaces: live.value ?? 0
+		},
+		error: minFree.error ?? hardFloor.error ?? memory.error ?? live.error
+	};
+}
+function existingAncestor(path) {
+	let current = path;
+	while (!existsSync(current) && dirname$1(current) !== current) current = dirname$1(current);
+	return current;
+}
+function readVolumeSpace(paths) {
+	const seen = /* @__PURE__ */ new Set();
+	const volumes = [];
+	for (const path of paths) try {
+		const existing = existingAncestor(path);
+		const device = statSync(existing).dev;
+		if (seen.has(device)) continue;
+		seen.add(device);
+		const fs = statfsSync(existing);
+		volumes.push({
+			volume: volumeRootFor(path),
+			freeMb: fs.bavail * fs.bsize / MB
+		});
+	} catch {}
+	return volumes;
+}
+function estimateMemoryUse({ config, sims, androidSerial, supervisorRunning }) {
+	const simsByUdid = Object.fromEntries((sims ?? []).map((sim) => [sim.udid, sim]));
+	const runtime = (avdName) => {
+		if (!avdName) return null;
+		const serial = androidSerial(avdName);
+		return {
+			serial,
+			state: serial ? "detected" : "not-detected"
+		};
+	};
+	const states = Object.entries(config?.projects ?? {}).map(([path, project]) => {
+		const pid = supervisorRunning(path, project);
+		const slots = projectDeviceSlots(project);
+		return environmentState({
+			...project,
+			__path: path
+		}, {
+			simsByUdid,
+			simsAvailable: sims !== null,
+			metro: pid === null ? { missing: true } : { metro: { pid } },
+			androidRuntime: project.platforms?.android?.owned ? runtime(project.platforms.android.avdName) : null,
+			androidRuntimes: Object.fromEntries(slots.slice(1).map(({ slot, platforms }) => [slot, platforms.android?.owned ? runtime(platforms.android.avdName) : null]))
+		});
+	});
+	const { committedMb, liveCount } = capacity(states, 0);
+	return {
+		committedMb,
+		liveWorkspaces: liveCount
+	};
+}
+function listSims() {
+	try {
+		return listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+	} catch {
+		return null;
+	}
+}
+function runningSupervisorPid(path, project) {
+	const target = resolveSupervisorTarget({
+		state: readWorkspaceState$1(path)?.supervisor,
+		record: project.supervisor,
+		reservedPort: project.metroPort
+	});
+	return target.status === "ours" ? target.pid ?? null : null;
+}
+function readMemoryUse() {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return estimateMemoryUse({
+		config: loadConfig$1(),
+		sims: listSims(),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		},
+		supervisorRunning: runningSupervisorPid
+	});
+}
+function budgetShortfalls(budget, measure) {
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	return {
+		disk: floor > 0 ? measure.volumes.filter((v) => v.freeMb < floor) : [],
+		hardFloor: budget.hardFloorDiskMb > 0 ? measure.volumes.filter((v) => v.freeMb < budget.hardFloorDiskMb) : [],
+		memory: Boolean(budget.maxCommittedMemoryMb > 0 && measure.memory && measure.memory.committedMb > budget.maxCommittedMemoryMb),
+		workspaces: Boolean(budget.maxLiveWorkspaces > 0 && measure.memory && measure.memory.liveWorkspaces > budget.maxLiveWorkspaces)
+	};
+}
+const DISK_ONLY = ["workspace-outputs", "stale-cache-entries"];
+function reclaimPlan(short) {
+	const disk = short.disk.length > 0;
+	return [...disk || short.memory || short.workspaces ? ["idle-devices", "idle-dev-servers"] : [], ...disk ? DISK_ONLY : []];
+}
+function overBudget(short) {
+	return short.disk.length > 0 || short.memory || short.workspaces;
+}
+function isOtherWorkspace(root) {
+	const self = canonicalPath(root);
+	return (path) => canonicalPath(path) !== self;
+}
+function deviceLabel(device) {
+	return `${device.kind} ${device.name} in ${device.project}`;
+}
+function reclaimIdleDevices({ root, dryRun, note, now }) {
+	if (deviceSweepIsScoped()) {
+		note(chalk.dim(phaseLine("budget", "idle devices left alone: STIM_HOME scopes this config, devices are global")));
+		return {
+			targets: [],
+			failures: 0
+		};
+	}
+	const other = isOtherWorkspace(root);
+	const collect = (at) => idleShutdownCandidates(collectIdleDevices(loadConfig$1(), listSims() ?? [], [], at).filter((device) => other(device.project)), 0);
+	const idle = collect(now);
+	if (dryRun || idle.length === 0) return {
+		targets: idle.map(deviceLabel),
+		failures: 0
+	};
+	const { failures, shutDown } = shutDownIdleDevices(idle, 0, () => collect(Date.now()));
+	return {
+		targets: shutDown.map(deviceLabel),
+		failures
+	};
+}
+function idleSince(path, now) {
+	const activity = workspaceActivity(path, now);
+	const at = Date.parse(activity.lastActivityAt ?? "");
+	return activity.state === "idle" && Number.isFinite(at) ? at : null;
+}
+async function reclaimIdleDevServers({ root, dryRun, note, now }) {
+	const config = loadConfig$1();
+	const other = isOtherWorkspace(root);
+	const serving = Object.entries(config?.projects ?? {}).flatMap(([path, project]) => {
+		const pid = other(path) ? runningSupervisorPid(path, project) : null;
+		return pid !== null && !workspaceBuildInProgress(path) && idleSince(path, now) !== null ? [{
+			path,
+			pid
+		}] : [];
+	});
+	if (serving.length === 0) return {
+		targets: [],
+		failures: 0
+	};
+	const sims = listSims();
+	if (sims === null) {
+		note(chalk.dim(phaseLine("budget", "dev servers left alone: simulators could not be listed to prove them idle")));
+		return {
+			targets: [],
+			failures: 0
+		};
+	}
+	const busy = new Set(collectOwnedDeviceActivity(config, sims, now).filter((device) => device.activity.state !== "idle").map((device) => device.project));
+	const idle = serving.filter(({ path }) => !busy.has(path));
+	if (dryRun) return {
+		targets: idle.map(({ path }) => path),
+		failures: 0
+	};
+	const targets = [];
+	let failures = 0;
+	const stillIdle = (path, pid) => {
+		const project = loadConfig$1()?.projects?.[path];
+		return Boolean(project && runningSupervisorPid(path, project) === pid && !workspaceBuildInProgress(path) && idleSince(path, Date.now()) !== null);
+	};
+	for (const { path, pid } of idle) {
+		let run;
+		try {
+			run = await withIdleWorkspace(path, async () => {
+				try {
+					return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => stillIdle(path, pid) ? stopOwnedMetro(path) : "busy", {
+						external: true,
+						waitMs: 0,
+						ownerPurpose: "budget reclaim"
+					});
+				} catch (error) {
+					if (workspaceProcessLockError(error)) return "starting";
+					throw error;
+				}
+			}, {
+				purpose: "budget reclaim",
+				supervisor: false
+			});
+		} catch (error) {
+			failures++;
+			note(chalk.red(`Could not stop the dev server of ${path}: ${error?.message || error}`));
+			continue;
+		}
+		if (!run.ran) {
+			note(chalk.yellow(`Kept the dev server of ${path}: ${run.reasons.join("; ")}`));
+			continue;
+		}
+		const stopped = run.value;
+		if (stopped === "busy" || stopped === "starting") {
+			const why = stopped === "busy" ? "it is no longer idle" : "a stim start holds its metro-start lock";
+			note(chalk.dim(`Kept the dev server of ${path}: ${why}`));
+		} else if (stopped.status === "stopped") {
+			targets.push(path);
+			note(chalk.green(`Stopped the idle dev server of ${path}`));
+		} else if ("reason" in stopped) {
+			if (stopped.status === "stuck") failures++;
+			note(chalk.yellow(`Kept the dev server of ${path}: ${stopped.reason}`));
+		}
+	}
+	return {
+		targets,
+		failures
+	};
+}
+async function reclaimWorkspaceOutputs({ root, dryRun, now, diskRecovered }) {
+	const other = isOtherWorkspace(root);
+	const report = collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		measure: false
+	});
+	const clearable = report.workspaces.flatMap((entry) => {
+		const project = entry.projectRoot;
+		const since = project !== null && entry.willClear && other(project) ? idleSince(project, now) : null;
+		return since === null ? [] : [{
+			entry,
+			since
+		}];
+	}).toSorted((a, b) => a.since - b.since).map(({ entry }) => entry);
+	if (dryRun) return {
+		targets: clearable.map((entry) => entry.projectRoot),
+		failures: 0
+	};
+	const targets = [];
+	let failures = 0;
+	for (const entry of clearable) {
+		const result = await clearWorkspaceOutputs({
+			...report,
+			workspaces: [entry]
+		}, {
+			olderThan: null,
+			now
+		});
+		failures += result.failures;
+		targets.push(...result.cleared);
+		if (diskRecovered()) break;
+	}
+	return {
+		targets,
+		failures
+	};
+}
+function cacheLabel(cache) {
+	return `${cache.name} ${cache.dir}`;
+}
+function reclaimStaleCacheEntries({ dryRun }) {
+	const caches = planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+	if (dryRun) return {
+		targets: caches.map(cacheLabel),
+		failures: 0
+	};
+	return {
+		targets: trimCaches(caches, STALE_CACHE_DAYS).map(cacheLabel),
+		failures: 0
+	};
+}
+const STEPS = {
+	"idle-devices": reclaimIdleDevices,
+	"idle-dev-servers": reclaimIdleDevServers,
+	"workspace-outputs": reclaimWorkspaceOutputs,
+	"stale-cache-entries": reclaimStaleCacheEntries
+};
+const STEP_ACTIONS = {
+	"idle-devices": "shut down idle owned devices",
+	"idle-dev-servers": "stop idle dev servers",
+	"workspace-outputs": "clear build outputs of idle workspaces",
+	"stale-cache-entries": `trim cache entries unused for ${STALE_CACHE_DAYS} days`
+};
+async function runStep(step, context) {
+	const log = console.log;
+	const exitCode = process.exitCode;
+	console.log = console.error;
+	try {
+		const result = await STEPS[step](context);
+		return process.exitCode === exitCode ? result : {
+			...result,
+			failures: result.failures + 1
+		};
+	} catch (error) {
+		context.note(chalk.red(phaseLine("budget", `${STEP_ACTIONS[step]} failed: ${error?.message || error}`)));
+		return {
+			targets: [],
+			failures: 1
+		};
+	} finally {
+		console.log = log;
+		process.exitCode = exitCode;
+	}
+}
+function spaceUsers() {
+	const home = homedir$1();
+	const candidates = [
+		["Stim state", getConfigDir()],
+		["shared build cache", sharedBuildCache()],
+		...platform() === "darwin" ? [["simulators", join$1(home, "Library", "Developer", "CoreSimulator", "Devices")], ["Xcode DerivedData", join$1(home, "Library", "Developer", "Xcode", "DerivedData")]] : [],
+		["Android emulators", join$1(home, ".android", "avd")]
+	];
+	const measured = /* @__PURE__ */ new Set();
+	const users = [];
+	for (const [label, path] of candidates) {
+		const canonical = canonicalPath(path);
+		if (measured.has(canonical) || [...measured].some((dir) => canonical.startsWith(`${dir}${sep$1}`))) continue;
+		measured.add(canonical);
+		if (!existsSync(path)) continue;
+		const bytes = measuredDirectorySize(path, { timeoutMs: USAGE_TIMEOUT_MS });
+		if (bytes) users.push({
+			label: `${label} ${path}`,
+			bytes
+		});
+	}
+	return users.toSorted((a, b) => b.bytes - a.bytes).map(({ label, bytes }) => `${label}: ${formatBytes(bytes)}`);
+}
+const DEFAULT_DEPS = {
+	volumes: readVolumeSpace,
+	memory: readMemoryUse,
+	step: runStep,
+	usage: spaceUsers,
+	now: Date.now
+};
+const LOW_DISK_REMEDY = "Run `stim gc` to see what else Stim can reclaim, then `stim gc --delete` (add `--cache all` to empty the shared caches, or `--worktrees` to remove finished worktrees). Free space outside Stim from the largest uses listed, or lower budget.hardFloorDiskGb.";
+function describeShortfall(budget, measure, short) {
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	return [
+		...short.disk.map((v) => `${formatSpace(v.freeMb)} free on ${v.volume}, below the ${formatSpace(floor)} floor`),
+		...short.memory && measure.memory ? [`roughly ${formatSpace(measure.memory.committedMb)} of memory committed, over the ${formatSpace(budget.maxCommittedMemoryMb)} budget`] : [],
+		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} live workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
+	];
+}
+async function enforceBudget({ root, note, dryRun = false, budget: resolved }, overrides = {}) {
+	const deps = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	let budget = resolved;
+	if (!budget) {
+		const read = resolveBudget();
+		if (read.error) return {
+			status: "invalid",
+			refusal: {
+				code: "STIM_BAD_ARG",
+				message: read.error,
+				remedy: BUDGET_SETTING_REMEDY
+			}
+		};
+		budget = read.budget;
+	}
+	const paths = [root, getConfigDir()];
+	const measureNow = () => ({
+		volumes: budget.minFreeDiskMb > 0 || budget.hardFloorDiskMb > 0 ? deps.volumes(paths) : [],
+		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory() : null
+	});
+	let measure = measureNow();
+	let short = budgetShortfalls(budget, measure);
+	const reclaimed = [];
+	const plan = reclaimPlan(short);
+	if (plan.length) note(chalk.yellow(phaseLine("budget", `${describeShortfall(budget, measure, short).join("; ")}; ${dryRun ? "would reclaim" : "reclaiming"}`)));
+	for (const step of plan) {
+		if (!dryRun && (!overBudget(short) || DISK_ONLY.includes(step) && short.disk.length === 0)) break;
+		const freeBefore = measure.volumes.reduce((sum, v) => sum + v.freeMb, 0);
+		const result = await deps.step(step, {
+			root,
+			dryRun,
+			note,
+			now: deps.now(),
+			diskRecovered: () => budgetShortfalls(budget, {
+				volumes: deps.volumes(paths),
+				memory: null
+			}).disk.length === 0
+		});
+		if (!dryRun) {
+			measure = measureNow();
+			short = budgetShortfalls(budget, measure);
+		}
+		if (result.targets.length === 0 && result.failures === 0) continue;
+		const freedMb = Math.max(0, Math.round(measure.volumes.reduce((sum, v) => sum + v.freeMb, 0) - freeBefore));
+		reclaimed.push({
+			step,
+			...result,
+			...dryRun ? {} : { freedMb }
+		});
+		const outcome = dryRun ? result.targets.join(", ") : `${result.targets.length}${result.failures ? `, ${result.failures} failed` : ""} (${formatSpace(freedMb)} freed)`;
+		note(chalk.dim(phaseLine("budget", `${STEP_ACTIONS[step]}: ${outcome}`)));
+	}
+	if (!dryRun && short.hardFloor.length) {
+		const tight = short.hardFloor.map((v) => `${formatSpace(v.freeMb)} on ${v.volume}`).join(" and ");
+		const users = deps.usage();
+		return {
+			status: "refused",
+			reclaimed,
+			refusal: {
+				code: "STIM_LOW_DISK",
+				message: `Only ${tight} is free, below the ${formatSpace(budget.hardFloorDiskMb)} hard floor (budget.hardFloorDiskGb)${reclaimed.length ? " after reclaiming what Stim safely could" : ""}, so this run could fill the disk.` + (users.length ? ` Largest uses: ${users.join("; ")}.` : ""),
+				remedy: LOW_DISK_REMEDY
+			}
+		};
+	}
+	if (!dryRun && overBudget(short)) note(chalk.yellow(phaseLine("budget", `still over budget: ${describeShortfall(budget, measure, short).join("; ")}`)));
+	return {
+		status: "ok",
+		reclaimed,
+		budget,
+		measure,
+		short
+	};
+}
+async function budgetGate(args, overrides = {}) {
+	const outcome = await enforceBudget(args, overrides);
+	return {
+		reclaimed: "reclaimed" in outcome ? outcome.reclaimed : [],
+		refusal: outcome.status === "ok" ? null : outcome.refusal
+	};
+}
+const gb = (mb) => Math.round(mb / GB_IN_MB * 10) / 10;
+function budgetFindings(budget, measure, short, plan) {
+	const findings = [];
+	const steps = plan.length ? plan.map((entry) => `${STEP_ACTIONS[entry.step]} (${entry.targets.join(", ")})`).join("; then ") : "nothing Stim can reclaim on its own right now";
+	if (short.disk.length) {
+		const refuses = short.hardFloor.length ? ` Below ${formatSpace(budget.hardFloorDiskMb)} it refuses with STIM_LOW_DISK when reclaiming does not free enough.` : "";
+		findings.push({
+			level: "cost",
+			title: "Free disk is below the Stim budget",
+			detail: `${describeShortfall(budget, measure, {
+				...short,
+				memory: false,
+				workspaces: false
+			}).join("; ")}. The next ios, android or start will first ${steps}.${refuses}`,
+			fix: "Run `stim gc` to see what Stim can reclaim, then `stim gc --delete`. Free space outside Stim, or lower budget.minFreeDiskGb."
+		});
+	}
+	if (short.memory || short.workspaces) findings.push({
+		level: "note",
+		title: "Live environments are over the memory budget",
+		detail: `${describeShortfall(budget, measure, {
+			...short,
+			disk: []
+		}).join("; ")}. The next ios, android or start shuts down idle owned devices and stops idle dev servers in other workspaces first.`,
+		fix: "Run `stim status` to see what is live, and `stim stop` in workspaces you own that you no longer need."
+	});
+	return findings;
+}
+async function inspectBudget(root, deps = {}) {
+	const read = resolveBudget();
+	if (read.error) return {
+		report: null,
+		findings: [{
+			level: "cost",
+			title: "A budget setting is invalid",
+			detail: read.error,
+			fix: BUDGET_SETTING_REMEDY
+		}]
+	};
+	const outcome = await enforceBudget({
+		root,
+		note: () => {},
+		dryRun: true,
+		budget: read.budget
+	}, deps);
+	if (outcome.status !== "ok") return {
+		report: null,
+		findings: []
+	};
+	const { budget, measure, short, reclaimed } = outcome;
+	return {
+		report: {
+			budget: {
+				minFreeDiskGb: gb(budget.minFreeDiskMb),
+				hardFloorDiskGb: gb(budget.hardFloorDiskMb),
+				maxCommittedMemoryGb: gb(budget.maxCommittedMemoryMb),
+				maxLiveWorkspaces: budget.maxLiveWorkspaces
+			},
+			volumes: measure.volumes.map((v) => ({
+				volume: v.volume,
+				freeGb: gb(v.freeMb)
+			})),
+			memory: measure.memory ? {
+				committedGb: gb(measure.memory.committedMb),
+				liveWorkspaces: measure.memory.liveWorkspaces
+			} : null,
+			plan: reclaimed
+		},
+		findings: budgetFindings(budget, measure, short, reclaimed)
+	};
+}
+function budgetLine(report) {
+	const { budget } = report;
+	return `${report.volumes.length ? `${report.volumes.map((v) => `${v.freeGb} GB free on ${v.volume}`).join(", ")} (reclaims below ${Math.max(budget.minFreeDiskGb, budget.hardFloorDiskGb)} GB, ${budget.hardFloorDiskGb ? `refuses below ${budget.hardFloorDiskGb} GB` : "never refuses"})` : "disk budget off"}; ${report.memory ? `roughly ${report.memory.committedGb} GB of a ${budget.maxCommittedMemoryGb} GB memory budget committed` : "memory budget off"}`;
+}
+//#endregion
+export { includesWorkspaceOutputs as A, deviceSweepIsScoped as C, unverifiedDeviceCommand as D, findStaleProjectDevices as E, sizeCaches as F, stopOwnedMetroForReset as I, selectCaches as M, trimCaches as N, withAndroidAvdSizes as O, discoverCaches as P, describeUnverifiableDevices as S, findStaleDeviceRecords as T, collectParkedSims as _, REBUILD_COST as a, deleteProjectDevices as b, collectOrphanedWorkspaces as c, isInsideWorkspaces as d, listWorkspaceDirs as f, collectParkedAvds as g, collectDeviceLeases as h, machineNumber as i, planCacheEmptying as j, emptyCaches as k, collectWorkspaceOutputs as l, DEVICE_LIST_TIMEOUT_MS$1 as m, budgetLine as n, WORKSPACE_OUTPUT_DIRS as o, sizeText as p, inspectBudget as r, clearWorkspaceOutputs as s, budgetGate as t, deleteOrphanedWorkspaces as u, deleteParkedAvds as v, findOrphanedDevices as w, describeParkedSims as x, deleteParkedSims as y };