stim 1.17.2 → 1.19.0

package/dist/preview-BbSottmO.mjs

@@ -0,0 +1,986 @@
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-Bt8ygHE7.mjs";
+import { H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, p as getProject } from "./config-DC5jEtd1.mjs";
+import { C as workspaceStateFile, r as readWorkspaceState$1, s as workspaceLastUsed, x as workspaceLogsDir$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { r as findProjectRoot } from "./project-B5eQ1USs.mjs";
+import { D as projectMaintenancePinned, ht as resolveFullRef, it as hasPopulatedSubmodules, lt as listWorktrees, ot as hasUncommittedWork, tt as dirtyPaths, vt as sourceCheckoutOf, yt as unpushedCommits } from "./settings-CxgngUZk.mjs";
+import { n as readManifest } from "./cache-manifest-DiwKSyv9.mjs";
+import { At as phase, G as DEVICE_LIST_TIMEOUT_MS, Nt as discoverCaches, c as readVolumeSpace, i as enforceBudget, l as resolveBudget, o as machineNumber, pt as planCacheEmptying, r as cacheLabel, u as trimmableCaches } from "./budget-Dz-kyXLv.mjs";
+import { F as recordGcResult, L as canonicalPath, N as listBuildSlots, a as collectWorkspaceOutputs, c as listWorkspaceDirs, i as collectOrphanedWorkspaces, p as workspaceInUse, s as isInsideWorkspaces } from "./workspaces-Djb2gfi9.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-Cu7PtQpZ.mjs";
+import { pt as readParked, z as ownedAvdSerialResolver } from "./android-BdQC6zs1.mjs";
+import { M as readHostMemoryPressure, d as listAllIosSims } from "./ios-BWbHFZVz.mjs";
+import { a as metroStoreRoot } from "./metro-store-BAHFcJm6.mjs";
+import { n as describePullRequest, o as pullRequestLookups, r as endedPullRequest } from "./pull-request-IHNdMnG8.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { o as fetchDefaultBranch, s as mergeState } from "./warm-progress-pFLB2e6P.mjs";
+import { f as removeWorktreeTarget, i as matchWorktreeEntry, n as excludePodChurn, o as reclaimKeys, r as excludeWatchmanCookies } from "./worktree-BL4M1rhB.mjs";
+import { existsSync } from "node:fs";
+import { basename, isAbsolute, join, sep } from "node:path";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
+import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, buildWorkerRoot, loadConfig, readMaintenanceState, settingDefinition, sharedCcache, sharedCompilationCache } from "@stim-cli/core/state";
+import { cpus, freemem, loadavg, totalmem } from "node:os";
+import chalk from "chalk";
+import { existsSync as existsSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
+import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
+//#region src/maintenance/measure.ts
+function measureDisk() {
+	return readVolumeSpace([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	]);
+}
+function measurePressure(settings, previous, now) {
+	const level = readHostMemoryPressure();
+	const availableBytes = process.platform === "darwin" ? null : freemem();
+	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
+	const pressured = settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3));
+	return {
+		disk: measureDisk(),
+		memory: {
+			level,
+			availableBytes,
+			pressured
+		},
+		warningSince
+	};
+}
+function sizeScanDeferred(settings) {
+	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
+}
+function cacheBlocked(entry, discovered = discoverCaches()) {
+	return planCacheEmptying([{
+		...entry,
+		note: "",
+		prune: "entries",
+		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
+	}], false)[0]?.machineGlobal ?? (entry.category === "compilation-cache" && [...listBuildLocks(), ...listBuildSlots()].some((item) => item.alive || item.unresolved) ? "a build lock or slot is live or unresolved" : void 0);
+}
+function measureSizes(now, failure) {
+	const sizes = [];
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		sizeTimeoutMs: 12e4
+	});
+	for (const entry of outputs.workspaces) {
+		if (entry.bytes === null) {
+			failure(entry.dir, entry.projectRoot ?? void 0);
+			continue;
+		}
+		sizes.push({
+			name: "workspace build outputs",
+			category: "workspace-outputs",
+			dir: entry.dir,
+			bytes: entry.bytes,
+			measuredAt: now,
+			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
+			idleDays: entry.idleDays,
+			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
+		});
+	}
+	const known = [
+		{
+			name: "shared build cache",
+			dir: buildCacheRoot(),
+			category: "build-cache"
+		},
+		{
+			name: "Metro transform caches",
+			dir: metroCacheRoot(),
+			category: "metro-cache"
+		},
+		{
+			name: "ccache",
+			dir: sharedCcache(),
+			category: "ccache"
+		},
+		{
+			name: "Swift compilation cache",
+			dir: sharedCompilationCache(),
+			category: "compilation-cache"
+		}
+	];
+	const discovered = discoverCaches();
+	for (const cache of discovered) {
+		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
+		if (cache.prune === "report-only") continue;
+		const dir = canonicalPath(cache.dir);
+		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
+		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
+		known.push({
+			name: cache.name,
+			dir: cache.dir,
+			category
+		});
+	}
+	for (const entry of known) {
+		if (!existsSync(entry.dir)) continue;
+		const bytes = measuredDirectorySize(entry.dir, { timeoutMs: 12e4 });
+		if (bytes === null) {
+			failure(entry.dir);
+			continue;
+		}
+		const blocked = cacheBlocked(entry, discovered);
+		sizes.push({
+			...entry,
+			bytes,
+			measuredAt: now,
+			...blocked ? { blocked } : {}
+		});
+	}
+	return sizes;
+}
+//#endregion
+//#region src/commands/gc/worktrees.ts
+const DEFAULT_WORKTREE_IDLE_DAYS = 7;
+const DAY_MS = 864e5;
+const MINUTE_MS = 6e4;
+const GRACE_SETTING = "gc.worktreeGraceMinutes";
+const MERGE_DECIDES = /* @__PURE__ */ new Set([
+	"unpushed",
+	"not-merged",
+	"last-use-unknown",
+	"recently-used"
+]);
+function skip(code, text) {
+	return {
+		code,
+		text
+	};
+}
+function pullRequestNote(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	if (!pr) return null;
+	return pr.containsHead ? describePullRequest(pr) : `${describePullRequest(pr)}, and HEAD has commits it does not`;
+}
+/**
+* Why gc keeps a worktree, or null when it removes it. A worktree that would be removed is still kept while its last
+* activity, or its merge into the default branch, is less than `grace.ms` old, and kept when that activity is unknown.
+*/
+function worktreeSkipReason(facts, olderThan, grace = {
+	ms: 0,
+	now: 0
+}) {
+	return removalBlocker(facts, olderThan) ?? graceBlocker(facts, grace);
+}
+function graceBlocker(facts, grace) {
+	if (grace.ms <= 0) return null;
+	if (!facts.activity) return skip("activity-unknown", "its last activity could not be read");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	const ended = endedPullRequest(facts.pullRequest);
+	const events = [facts.activity];
+	if (merged) events.push({
+		at: merged.mergedAt,
+		basis: `merged into ${merged.into}`
+	});
+	if (ended?.endedAt) events.push({
+		at: ended.endedAt,
+		basis: describePullRequest(ended)
+	});
+	const latest = events.reduce((a, b) => b.at > a.at ? b : a);
+	const eligibleAt = latest.at + grace.ms;
+	if (grace.now >= eligibleAt) return null;
+	const ago = formatLongDuration(Math.max(0, grace.now - latest.at));
+	return {
+		code: "recent-activity",
+		text: `recent activity: ${latest.basis} ${ago} ago; removable after ${new Date(eligibleAt).toISOString()}`,
+		eligibleAt
+	};
+}
+function removalBlocker(facts, olderThan) {
+	if (facts.bare) return skip("bare-repository", "bare repository");
+	if (typeof facts.source === "object") return skip("source-checkout-unknown", `source checkout unknown: ${facts.source.refusal}`);
+	if (facts.source === "source") return skip("source-checkout", "source checkout");
+	if (facts.locked) return skip("locked", "locked with git worktree lock");
+	if (facts.inUse.length) return skip("in-use", `in use: ${facts.inUse.join("; ")}`);
+	if (facts.porcelain === null) return skip("status-unreadable", "git status could not be read");
+	const dirty = excludePodChurn(excludeWatchmanCookies(facts.porcelain).lines).lines.length;
+	if (dirty) return skip("dirty", `dirty: ${plural(dirty, "uncommitted or untracked file")}`);
+	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	const ended = endedPullRequest(facts.pullRequest);
+	if (facts.unpushed.length && !merged?.coversUnpushed && ended?.state !== "merged") return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
+	if (facts.submodules) return skip("submodules", "initialized submodules");
+	if (merged || ended) return null;
+	const notMerged = facts.merge && !facts.merge.merged ? facts.merge : null;
+	const details = [notMerged?.detail, pullRequestNote(facts.pullRequest)].filter(Boolean);
+	if (olderThan === null) return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", details.join("; ") || "not merged");
+	const also = details.map((detail) => `; ${detail}`).join("");
+	if (facts.idleDays === null) return skip("last-use-unknown", `recently used: its last use is unknown${also}`);
+	if (facts.idleDays < olderThan) return skip("recently-used", `recently used ${facts.idleDays}d ago${also}`);
+	return null;
+}
+/** Why gc removes a worktree it did not skip: `merged into origin/main`, `PR #12 closed` or `idle 9d`. */
+function worktreeRemovalReason(candidate) {
+	if (candidate.merge?.merged) return `merged into ${candidate.merge.into}`;
+	const ended = endedPullRequest(candidate.pullRequest);
+	return ended ? describePullRequest(ended) : `idle ${candidate.idleDays ?? 0}d`;
+}
+/** The pull request note a kept worktree's report line carries, such as `PR #12 merged`, or null. */
+function worktreePullRequestNote(candidate) {
+	return pullRequestNote(candidate.pullRequest);
+}
+function lastUsedOf(keys) {
+	const times = keys.map(workspaceLastUsed).filter(Number.isFinite);
+	return times.length ? Math.max(...times) : NaN;
+}
+function idleDaysOf(keys, now) {
+	const last = lastUsedOf(keys);
+	return Number.isFinite(last) ? Math.max(0, Math.floor((now - last) / DAY_MS)) : null;
+}
+function deviceReads() {
+	let sims;
+	let resolver;
+	return {
+		sims: () => {
+			if (sims === void 0) try {
+				sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			} catch {
+				sims = null;
+			}
+			return sims;
+		},
+		avdSerial: (avdName) => (resolver ??= ownedAvdSerialResolver({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }))(avdName)
+	};
+}
+function inUseOf(keys, checks, devices = deviceReads()) {
+	return [.../* @__PURE__ */ new Set([...keys.flatMap((key) => workspaceInUse(key, checks)), ...deviceUseOf(keys, devices)])];
+}
+function deviceUseOf(keys, devices) {
+	const reasons = [];
+	for (const key of keys) {
+		let slots;
+		try {
+			slots = projectDeviceSlots(getProject(key));
+		} catch (error) {
+			reasons.push(`its device records cannot be read: ${error.message}`);
+			continue;
+		}
+		for (const { platforms } of slots) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid) {
+				const sims = devices.sims();
+				const sim = sims?.find((entry) => entry.udid === ios.deviceUdid);
+				if (sims === null) reasons.push(`the state of its owned simulator ${ios.deviceUdid} cannot be read`);
+				else if (sim && sim.state !== "Shutdown") reasons.push(`its owned simulator ${sim.name} is ${sim.state}; \`stim stop\` in ${key} shuts it down`);
+			}
+			const android = platforms.android;
+			if (android?.owned && android.avdName) try {
+				if (devices.avdSerial(android.avdName).serial) reasons.push(`its owned emulator ${android.avdName} is running; \`stim stop\` in ${key} shuts it down`);
+			} catch {
+				reasons.push(`the state of its owned emulator ${android.avdName} cannot be read`);
+			}
+		}
+	}
+	const holders = new Set(keys.map(canonicalPath));
+	const now = Date.now();
+	for (const { lease } of listLeaseFiles()) if (lease && !leaseIsExpired(lease, now) && holders.has(canonicalPath(lease.holder))) reasons.push(`it holds the ${lease.platform} device lease on ${lease.deviceName ?? lease.id}`);
+	return reasons;
+}
+function newestMtime(paths) {
+	let newest = null;
+	for (const { path, basis } of paths) {
+		let mtime;
+		try {
+			mtime = statSync$1(path).mtimeMs;
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			return "unreadable";
+		}
+		if (!newest || mtime > newest.at) newest = {
+			at: mtime,
+			basis
+		};
+	}
+	return newest;
+}
+function logFiles$1(key) {
+	const dir = workspaceLogsDir$1(key);
+	try {
+		return readdirSync$1(dir).filter((name) => !name.startsWith(MAINTENANCE_LOG_NAME)).map((name) => ({
+			path: join$1(dir, name),
+			basis: "a Stim log write"
+		}));
+	} catch (error) {
+		return error.code === "ENOENT" ? [] : null;
+	}
+}
+function worktreeActivityOf(path, keys) {
+	const gitDir = getExecutor().runFileQuiet("git", [
+		"--no-optional-locks",
+		"-C",
+		path,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir"
+	])?.trim();
+	if (!gitDir) return null;
+	const paths = [
+		{
+			path: join$1(gitDir, "index"),
+			basis: "a git index write"
+		},
+		{
+			path: join$1(gitDir, "HEAD"),
+			basis: "a git HEAD change"
+		},
+		{
+			path: join$1(gitDir, "logs", "HEAD"),
+			basis: "a git reflog entry"
+		}
+	];
+	for (const key of keys) {
+		const logs = logFiles$1(key);
+		if (logs === null) return null;
+		paths.push({
+			path: workspaceStateFile(key),
+			basis: "a Stim workspace state write"
+		}, ...logs);
+	}
+	const newest = newestMtime(paths);
+	return newest === "unreadable" ? null : newest;
+}
+function graceMsSetting() {
+	const { value, error } = machineNumber(GRACE_SETTING, loadConfig$1(), process.env);
+	if (error) {
+		const fallback = Number(settingDefinition(GRACE_SETTING)?.default);
+		console.error(chalk.yellow(`${error} gc uses the default of ${fallback} minutes.`));
+		return fallback * MINUTE_MS;
+	}
+	return (value ?? 0) * MINUTE_MS;
+}
+function porcelainOf(path, gitAnswered) {
+	if (gitAnswered === null) return null;
+	if (!gitAnswered) return [];
+	const lines = dirtyPaths(path, { limit: Infinity });
+	return lines.length ? lines : null;
+}
+function candidateRoots() {
+	const registered = Object.keys(loadConfig$1()?.projects ?? {}).filter(isAbsolute$1);
+	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
+	return [.../* @__PURE__ */ new Set([...registered, ...recorded])].filter((root) => existsSync$1(root)).toSorted();
+}
+function checkMergeStates(pending, idle, grace) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const entry of pending) repos.set(entry.repo, [...repos.get(entry.repo) ?? [], entry]);
+	for (const [repo, entries] of repos) {
+		const target = fetchDefaultBranch(repo, grace.now);
+		for (const { candidate, facts } of entries) {
+			const merge = "error" in target ? {
+				merged: false,
+				unknown: true,
+				detail: `merge state unknown: ${target.error}`
+			} : mergeState(candidate.path, target);
+			const verdict = worktreeSkipReason({
+				...facts,
+				merge
+			}, idle, grace);
+			Object.assign(candidate, {
+				merge,
+				skipCode: verdict?.code ?? null,
+				skipped: verdict?.text ?? null,
+				eligibleAt: verdict?.eligibleAt ?? null
+			});
+		}
+	}
+}
+/**
+* Classifies each Stim-managed linked worktree. A merged one is removable; with `idle`, so is one unused for
+* `olderThan` days. Device use is read last, in one pass against one simulator list and one AVD resolver, so
+* the resolver's time budget covers only device reads. Pull requests are asked once per repository, all
+* repositories at once. Merge state is checked only where it decides the verdict, after one fetch per repository.
+*/
+async function collectWorktreeSweep({ idle, olderThan, now }) {
+	const days = idle ? olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS : null;
+	const grace = {
+		ms: graceMsSetting(),
+		now
+	};
+	const groups = /* @__PURE__ */ new Map();
+	const outside = [];
+	const candidates = candidateRoots();
+	if (candidates.length) phase("worktrees", `checking ${plural(candidates.length, "project")} for merged or idle worktrees`);
+	for (const root of candidates) {
+		const entry = matchWorktreeEntry(listWorktrees(root), root);
+		if (!entry) {
+			outside.push({
+				path: root,
+				keys: [root],
+				idleDays: null,
+				merge: null,
+				head: null,
+				pullRequest: null,
+				skipCode: "not-a-worktree",
+				skipped: "not inside a git worktree",
+				eligibleAt: null
+			});
+			continue;
+		}
+		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
+	}
+	const inspected = [];
+	for (const [path, roots] of groups) {
+		const entries = listWorktrees(path);
+		const entry = matchWorktreeEntry(entries, path);
+		const source = sourceCheckoutOf(entries);
+		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
+		const idleDays = idleDaysOf(keys, now);
+		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
+		const activity = linked && grace.ms > 0 ? worktreeActivityOf(path, keys) : null;
+		const gitAnswered = linked ? hasUncommittedWork(path) : null;
+		const head = linked ? resolveFullRef(path, "HEAD") : null;
+		const facts = {
+			source: "refusal" in source ? source : linked ? "linked" : "source",
+			bare: Boolean(entry?.bare),
+			locked: Boolean(entry?.locked),
+			porcelain: porcelainOf(path, gitAnswered),
+			unpushed: linked ? unpushedCommits(path) : null,
+			submodules: linked && hasPopulatedSubmodules(path),
+			inUse: [],
+			idleDays,
+			merge: null,
+			pullRequest: null,
+			activity
+		};
+		inspected.push({
+			candidate: {
+				path,
+				keys,
+				idleDays,
+				merge: null,
+				head,
+				pullRequest: null,
+				skipCode: null,
+				skipped: null,
+				eligibleAt: null
+			},
+			facts,
+			repo: "refusal" in source ? null : source.path,
+			branch: head && entry?.branch ? entry.branch : null
+		});
+	}
+	const linked = inspected.filter(({ facts }) => facts.source === "linked");
+	for (const { candidate, facts } of linked) facts.inUse = candidate.keys.flatMap((key) => workspaceInUse(key, { managedLocks: true }));
+	const devices = deviceReads();
+	for (const { candidate, facts } of linked) facts.inUse = [.../* @__PURE__ */ new Set([...facts.inUse, ...deviceUseOf(candidate.keys, devices)])];
+	await lookUpPullRequests(inspected);
+	const worktrees = [];
+	const pending = [];
+	for (const { candidate, facts, repo } of inspected) {
+		const verdict = worktreeSkipReason(facts, days, grace);
+		Object.assign(candidate, {
+			pullRequest: facts.pullRequest,
+			skipCode: verdict?.code ?? null,
+			skipped: verdict?.text ?? null,
+			eligibleAt: verdict?.eligibleAt ?? null
+		});
+		if (verdict && MERGE_DECIDES.has(verdict.code) && repo !== null) pending.push({
+			candidate,
+			facts,
+			repo
+		});
+		worktrees.push(candidate);
+	}
+	checkMergeStates(pending, days, grace);
+	const listed = [...worktrees, ...outside].filter((w) => idle || w.skipCode !== "not-a-worktree" && w.skipCode !== "source-checkout");
+	return {
+		idle: days === null ? null : {
+			olderThan: days,
+			defaulted: olderThan === null
+		},
+		graceMs: grace.ms,
+		worktrees: listed
+	};
+}
+async function lookUpPullRequests(inspected) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const { candidate, facts, repo, branch } of inspected) {
+		if (repo === null || branch === null || candidate.head === null) continue;
+		const query = {
+			cwd: candidate.path,
+			branch,
+			head: candidate.head
+		};
+		repos.set(repo, [...repos.get(repo) ?? [], {
+			facts,
+			query
+		}]);
+	}
+	const lookup = pullRequestLookups();
+	await Promise.all([...repos].map(async ([repo, entries]) => {
+		const answers = await lookup(repo, entries.map(({ query }) => query));
+		entries.forEach(({ facts }, i) => facts.pullRequest = answers[i] ?? null);
+	}));
+}
+async function removeWorktrees(sweep, { now = Date.now() } = {}) {
+	let failures = 0;
+	for (const candidate of sweep.worktrees) {
+		if (candidate.skipped) continue;
+		let kept = [];
+		const guard = (lockedKeys) => {
+			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
+			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
+			const reasons = [...inUseOf(lockedKeys, { managedLocks: false }), ...inUseOf(unlocked, { managedLocks: true })].map((r) => `in use: ${r}`);
+			const mergedHead = candidate.merge?.merged ? candidate.merge.head : endedPullRequest(candidate.pullRequest) ? candidate.head : null;
+			if (mergedHead) {
+				if (resolveFullRef(candidate.path, "HEAD") !== mergedHead) reasons.push("its HEAD moved since gc checked it");
+			} else {
+				const idleDays = idleDaysOf(keys, now);
+				if (idleDays === null || !sweep.idle || idleDays < sweep.idle.olderThan) reasons.push(`used ${idleDays === null ? "at an unknown time" : `${idleDays}d ago`} since gc checked it`);
+			}
+			if (sweep.graceMs > 0) {
+				const recent = graceBlocker({
+					merge: candidate.merge,
+					pullRequest: candidate.pullRequest,
+					activity: worktreeActivityOf(candidate.path, keys)
+				}, {
+					ms: sweep.graceMs,
+					now: Date.now()
+				});
+				if (recent) reasons.push(recent.text);
+			}
+			kept = reasons;
+			return reasons;
+		};
+		let removed = false;
+		let error = null;
+		try {
+			const ended = endedPullRequest(candidate.pullRequest);
+			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : ended?.state === "merged" ? candidate.head ?? void 0 : void 0;
+			removed = await removeWorktreeTarget(candidate.path, {
+				linkedOnly: true,
+				guard,
+				mergedHead
+			});
+		} catch (thrown) {
+			error = thrown?.message || String(thrown);
+			console.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
+		}
+		if (removed) {
+			console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate)})`));
+			recordGcResult("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate) });
+		} else if (kept.length) {
+			console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
+			recordGcResult("worktree", "kept", candidate.path, { detail: kept.join("; ") });
+		} else {
+			failures++;
+			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
+			recordGcResult("worktree", "failed", candidate.path, { detail: error ?? "stim worktree remove did not remove it; see the details" });
+		}
+	}
+	return failures;
+}
+//#endregion
+//#region src/maintenance/protect.ts
+const BUILD_RECORDS = ["lastBuild", ...Object.values(LAST_BUILD_KEYS)];
+function recordKeys(record) {
+	if (record === null || typeof record !== "object") return [];
+	const value = record;
+	return [value.cacheKey, value.missReason?.baseline?.cacheKey].filter((key) => typeof key === "string");
+}
+function protectedCacheKeys(config = loadConfig$1()) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const root of Object.keys(config?.projects ?? {})) {
+		const state = readWorkspaceState$1(root);
+		for (const name of BUILD_RECORDS) for (const key of recordKeys(state?.[name])) keys.add(key);
+	}
+	for (const platform of ["ios", "android"]) for (const record of readParked(platform, { config })) if (record.cacheKey) keys.add(record.cacheKey);
+	for (const lock of listBuildLocks()) if ((lock.alive || lock.unresolved) && lock.key) keys.add(lock.key);
+	return keys;
+}
+function liveMetroStores(config = loadConfig$1()) {
+	return Object.keys(config?.projects ?? {}).filter((root) => workspaceInUse(root, {
+		managedLocks: false,
+		hosted: false,
+		nativeRun: false
+	}).length > 0).map((root) => canonicalPath(metroStoreRoot(root)));
+}
+function cacheEntryProtection(config = loadConfig$1()) {
+	try {
+		const keys = protectedCacheKeys(config);
+		const stores = liveMetroStores(config);
+		return (entry) => {
+			if (keys.has(basename(entry))) return "a project, parked device or running build still uses this build";
+			const path = canonicalPath(entry);
+			if (stores.some((store) => path === store || path.startsWith(`${store}${sep}`))) return "its project has a running or unverifiable dev server";
+			return null;
+		};
+	} catch (error) {
+		const reason = `cache protection could not be read: ${error instanceof Error ? error.message : String(error)}`;
+		return () => reason;
+	}
+}
+function recentUse(workspace, settings) {
+	const since = Date.now() - workspaceLastUsed(workspace);
+	return Number.isFinite(since) && since < settings.protectRecentHours * 36e5 ? `used within the last ${settings.protectRecentHours} hours` : null;
+}
+//#endregion
+//#region src/maintenance/plan.ts
+function plan({ pressure, sizes, settings, budget, diskSteps = [], protectedRoot, scoped = false, projects = [], pinned = () => false, recentlyUsed = () => null }) {
+	const actions = [];
+	const blocked = [];
+	const skips = [];
+	const add = (action) => {
+		if (action.kind === "would-clear-outputs" && action.workspace && pinned(action.workspace)) {
+			skips.push({
+				target: action.workspace,
+				reason: "pinned by maintenance.keep",
+				workspace: action.workspace
+			});
+			return false;
+		}
+		const recent = action.kind === "would-clear-outputs" && action.workspace ? recentlyUsed(action.workspace) : null;
+		if (recent) {
+			skips.push({
+				target: action.workspace,
+				reason: recent,
+				workspace: action.workspace
+			});
+			return false;
+		}
+		if (actions.some((entry) => entry.kind === action.kind && entry.target === action.target)) return false;
+		actions.push(action);
+		return true;
+	};
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const emergency = pressure?.disk.some((disk) => disk.freeMb < budget.hardFloorDiskMb) ?? false;
+	const low = pressure?.disk.filter((disk) => disk.freeMb < floor) ?? [];
+	const reason = low.map((disk) => `free disk ${(disk.freeMb / 1024).toFixed(1)}G on ${disk.volume} under the ${(floor / 1024).toFixed(1)}G floor`).join("; ");
+	const kinds = {
+		"idle-devices": "would-shutdown-device",
+		"idle-dev-servers": "would-stop-workspace",
+		"workspace-outputs": "would-clear-outputs",
+		"stale-cache-entries": "would-trim-cache"
+	};
+	if (low.length) {
+		for (const step of diskSteps) {
+			if (scoped && step.step === "idle-devices") continue;
+			for (const target of step.targets) {
+				const workspace = projects.find((root) => root === target || target.endsWith(` in ${root}`)) ?? (step.step === "idle-dev-servers" || step.step === "workspace-outputs" ? target : void 0);
+				if (workspace === protectedRoot || target === protectedRoot) continue;
+				const size = workspace && step.step !== "idle-devices" ? sizes.find((entry) => entry.workspace === workspace && entry.category === "workspace-outputs") : void 0;
+				add({
+					kind: kinds[step.step],
+					target,
+					bytes: step.step === "workspace-outputs" ? size?.bytes ?? 0 : 0,
+					reason: `${size?.idleDays == null ? "" : `idle ${size.idleDays} days, `}${reason}`,
+					...workspace ? { workspace } : {},
+					check: "disk",
+					...step.step === "stale-cache-entries" ? { olderThanDays: 14 } : {}
+				});
+			}
+			if (step.failures) blocked.push(`Could not plan ${step.step}: ${step.failures} failures`);
+		}
+		if (actions.length === 0) blocked.push(`${reason}; no reclaimable disk targets`);
+	}
+	const caps = [
+		[
+			"workspace-outputs",
+			settings.workspaceOutputsMaxGb,
+			"would-clear-outputs"
+		],
+		[
+			"build-cache",
+			settings.buildCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"metro-cache",
+			settings.metroCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"compilation-cache",
+			settings.swiftCompilationCacheMaxGb,
+			"would-empty-cache"
+		]
+	];
+	for (const [category, capGb, kind] of caps) {
+		const entries = sizes.filter((size) => size.category === category);
+		const total = entries.reduce((sum, size) => sum + size.bytes, 0);
+		const cap = capGb * 1024 ** 3;
+		if (cap === 0 || total <= cap) continue;
+		let remaining = total;
+		const targetBytes = cap * settings.capTargetPercent / 100;
+		const why = `${category} ${(total / 1024 ** 3).toFixed(1)}G over the ${capGb}G cap; target ${(targetBytes / 1024 ** 3).toFixed(1)}G`;
+		if (category === "compilation-cache" && !emergency) {
+			skips.push({
+				target: entries[0]?.dir ?? category,
+				reason: `${why}; it can only be emptied whole, which runs only below the ${(budget.hardFloorDiskMb / 1024).toFixed(1)}G hard floor`
+			});
+			continue;
+		}
+		for (const size of entries.toSorted((a, b) => (b.idleDays ?? 0) - (a.idleDays ?? 0))) {
+			if (remaining <= targetBytes) break;
+			const kept = size.workspace === protectedRoot ? "the triggering workspace is protected" : size.blocked;
+			if (kept) {
+				skips.push({
+					target: size.dir,
+					reason: kept,
+					...size.workspace ? { workspace: size.workspace } : {}
+				});
+				continue;
+			}
+			const bytes = kind === "would-trim-cache" ? Math.round(Math.min(size.bytes, remaining - targetBytes)) : size.bytes;
+			if (!add({
+				kind,
+				target: size.workspace ?? size.dir,
+				bytes,
+				reason: `${!size.workspace || size.idleDays == null ? "" : `idle ${size.idleDays} days, `}${why}`,
+				...size.workspace ? { workspace: size.workspace } : {},
+				...kind === "would-clear-outputs" ? {} : { dir: size.dir }
+			})) continue;
+			remaining -= bytes;
+		}
+		if (remaining > targetBytes) blocked.push(`${why}; eligible targets cannot reach the target`);
+	}
+	if (pressure?.memory.pressured) skips.push({
+		target: "memory",
+		reason: "memory pressure observed; automatic maintenance does not stop helpers or idle workspaces yet"
+	});
+	return {
+		actions,
+		blocked,
+		skips
+	};
+}
+//#endregion
+//#region src/maintenance/sweep.ts
+function planSweep({ settings, sizes, protectedRoot, pinned, now }) {
+	const actions = [];
+	const skips = [];
+	const blocked = [];
+	const days = settings.olderThanDays;
+	for (const entry of collectWorkspaceOutputs({
+		olderThan: days,
+		now,
+		measure: false
+	}).workspaces) {
+		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
+		if (root === null || !entry.willClear || root === protectedRoot) continue;
+		if (pinned(root)) {
+			skips.push({
+				target: root,
+				reason: "pinned by maintenance.keep",
+				workspace: root
+			});
+			continue;
+		}
+		const size = sizes.find((candidate) => candidate.workspace === root && candidate.category === "workspace-outputs");
+		actions.push({
+			kind: "would-clear-outputs",
+			target: root,
+			workspace: root,
+			bytes: size?.bytes ?? 0,
+			olderThanDays: days,
+			reason: `idle ${entry.idleDays} days, older than ${days} days (age sweep)`,
+			check: "sweep"
+		});
+	}
+	for (const cache of trimmableCaches().filter((candidate) => !isInsideWorkspaces(candidate.dir))) actions.push({
+		kind: "would-trim-cache",
+		target: cacheLabel(cache),
+		dir: cache.dir,
+		bytes: 0,
+		olderThanDays: days,
+		reason: `entries unused for ${days} days (age sweep)`,
+		check: "sweep"
+	});
+	try {
+		const orphans = collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes(), { measure: false });
+		for (const orphan of orphans.orphaned) actions.push({
+			kind: "would-remove-orphan",
+			target: orphan.dir,
+			bytes: orphan.bytes ?? 0,
+			reason: `its project ${orphan.projectRoot} no longer exists`,
+			check: "sweep"
+		});
+		for (const kept of orphans.skipped) skips.push({
+			target: kept.dir,
+			reason: kept.reason
+		});
+	} catch (error) {
+		blocked.push(`Could not look for orphaned workspace directories: ${error instanceof Error ? error.message : error}`);
+	}
+	const mounted = listMountedVolumes();
+	for (const cache of readManifest().caches) {
+		if (!isAbsolute(cache.dir) || existsSync(cache.dir) || !isOnMountedVolume(cache.dir, mounted)) continue;
+		actions.push({
+			kind: "would-unregister-cache",
+			target: cache.dir,
+			dir: cache.dir,
+			bytes: 0,
+			reason: "its directory no longer exists",
+			check: "sweep"
+		});
+	}
+	return {
+		actions,
+		blocked,
+		skips
+	};
+}
+async function planWorktrees({ protectedRoot, pinned, now }) {
+	const sweep = await collectWorktreeSweep({
+		idle: false,
+		olderThan: null,
+		now
+	});
+	const actions = [];
+	const skips = [];
+	const keep = [];
+	for (const worktree of sweep.worktrees) {
+		if (worktree.skipped) continue;
+		const path = canonicalPath(worktree.path);
+		const reason = protectedRoot === path || protectedRoot.startsWith(`${path}${sep}`) ? "the command that started this pass runs inside it" : worktree.keys.some(pinned) ? "pinned by maintenance.keep" : null;
+		if (reason) {
+			skips.push({
+				target: worktree.path,
+				reason
+			});
+			continue;
+		}
+		keep.push(worktree);
+		actions.push({
+			kind: "would-remove-worktree",
+			target: worktree.path,
+			bytes: 0,
+			reason: worktreeRemovalReason(worktree),
+			check: "worktree"
+		});
+	}
+	return {
+		actions,
+		blocked: [],
+		skips,
+		sweep: {
+			...sweep,
+			worktrees: keep
+		}
+	};
+}
+//#endregion
+//#region src/maintenance/preview.ts
+function triggeringRoot() {
+	return canonicalPath(findProjectRoot(process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
+}
+async function plannedMaintenance(pressure, sizes, settings, { devices = true, sweep = false, worktrees = false } = {}) {
+	const resolved = resolveBudget();
+	if (resolved.error) throw new Error(resolved.error);
+	const budget = {
+		...resolved.budget,
+		maxCommittedMemoryMb: 0,
+		maxLiveWorkspaces: 0
+	};
+	const root = triggeringRoot();
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const low = pressure?.disk.some((disk) => disk.freeMb < floor);
+	const outcome = low ? await enforceBudget({
+		root,
+		note: () => {},
+		dryRun: true,
+		budget
+	}, { volumes: () => pressure.disk }) : null;
+	if (outcome && outcome.status !== "ok") throw new Error(outcome.refusal.message);
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now: Date.now(),
+		measure: false
+	});
+	const result = plan({
+		pressure,
+		sizes: sizes.map((size) => {
+			if (size.category === "compilation-cache") return {
+				...size,
+				blocked: cacheBlocked(size)
+			};
+			if (!size.workspace) return size;
+			const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
+			return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
+		}),
+		settings,
+		budget,
+		diskSteps: outcome?.status === "ok" ? outcome.reclaimed.filter((step) => devices || step.step !== "idle-devices") : [],
+		protectedRoot: root,
+		scoped: Boolean(process.env.STIM_HOME),
+		projects: Object.keys(loadConfig()?.projects ?? {}).map(canonicalPath),
+		pinned: projectMaintenancePinned,
+		recentlyUsed: (workspace) => recentUse(workspace, settings)
+	});
+	const merge = (extra) => {
+		for (const action of extra.actions) if (!result.actions.some((entry) => entry.kind === action.kind && entry.target === action.target)) result.actions.push(action);
+		result.blocked.push(...extra.blocked);
+		result.skips.push(...extra.skips);
+	};
+	if (sweep) merge(planSweep({
+		settings,
+		sizes,
+		protectedRoot: root,
+		pinned: projectMaintenancePinned,
+		now: Date.now()
+	}));
+	if (worktrees) {
+		const planned = await planWorktrees({
+			protectedRoot: root,
+			pinned: projectMaintenancePinned,
+			now: Date.now()
+		});
+		merge(planned);
+		result.worktreeSweep = planned.sweep;
+	}
+	if (low) result.skips.push(...outputs.workspaces.filter((entry) => !entry.willClear && entry.keptReason).map((entry) => ({
+		target: entry.dir,
+		reason: entry.keptReason,
+		workspace: entry.projectRoot ?? void 0
+	})));
+	return result;
+}
+async function previewMaintenance({ devices = true } = {}) {
+	let settings;
+	try {
+		settings = resolveMaintenanceSettings();
+		const state = readMaintenanceState();
+		if (settings.invalid && settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			invalid: settings.invalid,
+			note: settings.invalid
+		};
+		if (settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			note: "maintenance.mode is off"
+		};
+		const pressure = measurePressure(settings, state?.pressure ?? null, Date.now());
+		return {
+			...await plannedMaintenance(pressure, state?.sizes ?? [], settings, {
+				devices,
+				sweep: true
+			}),
+			mode: settings.mode,
+			...settings.invalid ? { invalid: settings.invalid } : {},
+			pressure,
+			note: settings.invalid ?? (state === null ? "no pass has run yet; sizes have not been measured" : null)
+		};
+	} catch (error) {
+		return {
+			mode: settings?.mode ?? "off",
+			...settings?.invalid ? { invalid: settings.invalid } : {},
+			pressure: null,
+			actions: [],
+			blocked: [String(error)],
+			skips: [],
+			note: "maintenance preview failed"
+		};
+	}
+}
+//#endregion
+export { recentUse as a, worktreePullRequestNote as c, measureDisk as d, measurePressure as f, cacheEntryProtection as i, worktreeRemovalReason as l, sizeScanDeferred as m, previewMaintenance as n, collectWorktreeSweep as o, measureSizes as p, triggeringRoot as r, removeWorktrees as s, plannedMaintenance as t, cacheBlocked as u };