stim 1.17.2 → 1.19.0

package/dist/{ownership-BMLqyBgJ.mjs → workspaces-Djb2gfi9.mjs}

@@ -1,25 +1,193 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { D as withConfigLock, H as projectDeviceSlots, _ as loadConfig, d as getConfigDir, k as acquireAvdClaim, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
-import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+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 { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { gt as repoRoot, q as resolveTailscaleBinary } from "./settings-Cfd-0r2d.mjs";
-import { o as pidExists, u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
-import { g as workspaceAgentDeviceDir, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { _ as removeSingletonFiles, c as webClaimRoot, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, o as readWebRecord, t as CDP_PORT_LABEL } from "./state-PeQiJuIu.mjs";
-import { t as agentDeviceDaemon, u as readAgentDeviceRecords } from "./activity-IRvJY_ru.mjs";
-import { n as readCreatedDevices, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-CpvzBL25.mjs";
-import { B as ownedAvdSystemImage, I as ownedAvdDirectory, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, M as listOrphanedAvdDirectories, O as listAdbDevices, X as shutdownAndroidEmulator, Z as sleepSync, _ as avdStorageRoots, dt as parkSim, et as waitForAndroidEmulatorShutdown, f as assertOwnedAvdStopped, h as avdPathExists, it as isStimOwnedAvd, lt as eraseParkedAfter, mt as removeParkedAfter, nt as wipeAvdUserData, pt as readParked, x as deleteAvd } from "./android-B_YNZy61.mjs";
-import { E as shutdownIosSim, _ as parseRuntimeVersion, a as deleteIosSim, b as renameIosSim, f as listIosDeviceTypes, g as parkedSimName, o as deleteParkedIosSim, s as eraseIosSim, w as resolveOwnedIosSim } from "./ios-DSfnPfse.mjs";
-import { r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-import { r as releaseBrowserPort } from "./named-ports-C8m8EQs2.mjs";
-import { createHash, randomUUID } from "node:crypto";
-import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync } from "node:fs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
+import { D as withConfigLock$1, H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix, j as formatBytes, k as acquireAvdClaim, p as getProject, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
+import { S as workspaceName, g as workspaceAgentDeviceDir, r as readWorkspaceState$1, s as workspaceLastUsed, v as workspaceDir } from "./workspace-state-CR9X86xJ.mjs";
+import { Y as resolveTailscaleBinary, mt as repoRoot } from "./settings-CxgngUZk.mjs";
+import { d as signalProcessTree, s as pidExists } from "./metro-DI2AjPF_.mjs";
+import { _ as removeSingletonFiles, c as webClaimRoot, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, o as readWebRecord, t as CDP_PORT_LABEL, u as webFacts } from "./state-D2KtnALG.mjs";
+import { t as agentDeviceDaemon, u as readAgentDeviceRecords } from "./activity-BSw0x84R.mjs";
+import { h as listBuildLocks } from "./device-lease-Cu7PtQpZ.mjs";
+import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Kqiifsk2.mjs";
+import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-D0s26Hx5.mjs";
+import { B as ownedAvdSystemImage, I as ownedAvdDirectory, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, M as listOrphanedAvdDirectories, O as listAdbDevices, X as shutdownAndroidEmulator, Z as sleepSync, _ as avdStorageRoots, dt as parkSim, et as waitForAndroidEmulatorShutdown, f as assertOwnedAvdStopped, h as avdPathExists, it as isStimOwnedAvd, lt as eraseParkedAfter, mt as removeParkedAfter, nt as wipeAvdUserData, pt as readParked, x as deleteAvd } from "./android-BdQC6zs1.mjs";
+import { D as shutdownIosSim, T as resolveOwnedIosSim, _ as parkedSimName, c as eraseIosSim, o as deleteIosSim, p as listIosDeviceTypes, s as deleteParkedIosSim, v as parseRuntimeVersion, x as renameIosSim } from "./ios-BWbHFZVz.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError, r as releaseBrowserPort, s as workspaceProcessLockPath } from "./named-ports-B4iWH4E-.mjs";
+import { a as macosRuntimeClaim, n as macosDir } from "./state-Tp4uImDS.mjs";
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename as basename$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
+import { buildSlotsDir, hostedNativeRecords, isJsonObject, macosAppState, parseHostedNativePlacement, readJsonFile, readMacosRecord, requireAutomaticMachine, tryAcquireBuildSlotClaim, unreadableHostedNative } from "@stim-cli/core/state";
 import { homedir } from "node:os";
+import chalk from "chalk";
 import { isDeepStrictEqual } from "node:util";
+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 { createHash, randomUUID } from "node:crypto";
 import { resolve4 } from "node:dns/promises";
 import { request } from "node:https";
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return resolve$1(p);
+	}
+}
+//#endregion
+//#region src/commands/gc/results.ts
+const results = [];
+function recordGcResult(kind, status, label, { id = null, bytes = null, detail = null } = {}) {
+	results.push({
+		kind,
+		status,
+		label,
+		id,
+		bytes,
+		detail
+	});
+}
+function takeGcResults() {
+	return results.splice(0);
+}
+//#endregion
+//#region src/engine/build-slots.ts
+const SLOT_PREFIX = "slot-";
+const SLOT_POLL_MS = 1e3;
+const SLOT_PROGRESS_MS = 3e4;
+const SLOT_CEILING_MS = 54e5;
+function sleepAsync$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		index: typeof details.index === "number" ? details.index : null,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const got = tryAcquireBuildSlotClaim({
+		max,
+		details: {
+			projectRoot: root,
+			logFile
+		}
+	});
+	if (!got) return null;
+	declareSpawnsOn(got.claim);
+	return {
+		acquired: true,
+		path: got.path,
+		index: got.index,
+		slot: {
+			pid: got.claim.owner.pid,
+			index: got.index,
+			projectRoot: root,
+			startedAt: got.claim.startedAt,
+			logFile
+		},
+		claim: got.claim
+	};
+}
+function slotWaitingLine({ max, elapsedMs }) {
+	return `${"build".padEnd(11)} waiting for a build slot (all ${max} in use, ${formatElapsed(elapsedMs)} elapsed) -- stim guide lifecycle concurrency`;
+}
+async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.now, out = () => {}, waitingFor = () => {}, sleep = sleepAsync$1, intervalMs = SLOT_POLL_MS, progressMs = SLOT_PROGRESS_MS, ceilingMs = SLOT_CEILING_MS, automatic = false }) {
+	if (automatic) requireAutomaticMachine("build", "local");
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const started = now();
+	let lastProgress = started;
+	let waited = false;
+	try {
+		for (;;) {
+			if (automatic) requireAutomaticMachine("build", "local");
+			const got = tryAcquireBuildSlot({
+				max,
+				root,
+				logFile
+			});
+			if (got) return {
+				...got,
+				slotWaitMs: waited ? Math.max(0, Math.round(now() - started)) : 0
+			};
+			waited = true;
+			waitingFor({
+				kind: "build-slot",
+				inUse: max,
+				max,
+				since: new Date(started).toISOString()
+			});
+			const elapsed = now() - started;
+			if (elapsed >= ceilingMs) {
+				const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for one of ${max} build slots, and every slot is held by a process that is still running, or by a holder Stim cannot identify. Slots live under ` + buildSlotsDir() + "; remove a slot directory whose builder is not really building, or raise concurrency.maxBuilds.");
+				err.code = "STIM_BUILD_SLOT_TIMEOUT";
+				throw err;
+			}
+			if (now() - lastProgress >= progressMs) {
+				lastProgress = now();
+				out(slotWaitingLine({
+					max,
+					elapsedMs: elapsed
+				}));
+			}
+			await sleep(intervalMs);
+		}
+	} finally {
+		waitingFor(null);
+	}
+}
+function releaseBuildSlot(handle) {
+	if (!handle || handle.unlimited) return false;
+	stopDeclaringSpawnsOn(handle.claim);
+	return (0, ownership_claim_exports.releaseClaim)(handle.claim);
+}
+function listBuildSlots() {
+	const dir = buildSlotsDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const slots = [];
+	for (const name of names) {
+		if (!name.startsWith(SLOT_PREFIX)) continue;
+		const path = join(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		const index = Number(name.slice(5));
+		slots.push({
+			path,
+			name,
+			index: Number.isFinite(index) ? index : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return slots;
+}
+//#endregion
 //#region src/devices/agent-device-cleanup.ts
 function parseAgentDeviceSessions(output) {
 	const result = JSON.parse(output);
@@ -392,7 +560,7 @@ function teardownOwnedIosSim(udid, { del = false, label, park, workspace, shutdo
 	}
 }
 function assertAvdReferences(avdName, owner) {
-	const config = loadConfig();
+	const config = loadConfig$1();
 	if (!config) throw new Error("Cannot verify AVD references without a Stim config; the data was kept.");
 	if (owner && "projectPath" in owner && owner.expectedRecord && !isDeepStrictEqual(deviceSlotPlatforms(config.projects[owner.projectPath], owner.slot)?.android, owner.expectedRecord)) throw new Error(`AVD ${avdName} has a changed workspace record; its data was kept.`);
 	for (const [projectPath, project] of Object.entries(config.projects)) for (const { slot, platforms } of projectDeviceSlots(project)) {
@@ -405,7 +573,7 @@ function removeOrphanedAvdDirectory(candidate, owner) {
 	const surveyed = listOrphanedAvdDirectories(candidate.name).find((entry) => entry.directory === candidate.directory);
 	if (!surveyed || surveyed.name !== candidate.name || surveyed.dev !== candidate.dev || surveyed.ino !== candidate.ino) throw new Error(`AVD data at ${candidate.directory} changed or is registered; it was kept.`);
 	assertOwnedAvdStopped(candidate.name, { resolveDirectory: () => candidate.directory });
-	const detached = withConfigLock(() => {
+	const detached = withConfigLock$1(() => {
 		const current = lstatSync(candidate.directory);
 		if (!current.isDirectory() || current.dev !== candidate.dev || current.ino !== candidate.ino) throw new Error(`AVD data at ${candidate.directory} changed or is registered; it was kept.`);
 		assertAvdReferences(candidate.name, owner);
@@ -481,7 +649,7 @@ function serialFree(serial) {
 function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, park, owner, workspace, orphanedDirectory, onlyIfMissing = false, onWipeStart, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = assertOwnedAvdStopped, resolveAvd = resolveOwnedAvdSerial }) {
 	let parkFallback;
 	try {
-		if (del || wipe) withConfigLock(() => assertAvdReferences(avdName, owner));
+		if (del || wipe) withConfigLock$1(() => assertAvdReferences(avdName, owner));
 		const resolved = resolveAvd(avdName);
 		if (resolved.notOwned) return {
 			status: "skipped",
@@ -547,7 +715,7 @@ function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, park, o
 			if (current.notOwned || current.missing) throw new Error(`AVD ${avdName} changed before its data was wiped.`);
 			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before its data was wiped.`);
 			assertStopped(avdName);
-			withConfigLock(() => assertAvdReferences(avdName, owner));
+			withConfigLock$1(() => assertAvdReferences(avdName, owner));
 			const directory = ownedAvdDirectory(avdName);
 			if (!directory) throw new Error(`The data directory of AVD ${avdName} could not be resolved.`);
 			onWipeStart?.();
@@ -563,7 +731,7 @@ function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, park, o
 			if (current.missing) return teardownUnregisteredAvd(avdName, del, owner);
 			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before deletion.`);
 			assertStopped(avdName);
-			withConfigLock(() => assertAvdReferences(avdName, owner));
+			withConfigLock$1(() => assertAvdReferences(avdName, owner));
 			if (park && park.max > 0) try {
 				const systemImage = ownedAvdSystemImage(avdName);
 				if (!systemImage || !park.configuration || !ownedAvdMatchesConfiguration(avdName, park.configuration)) throw new Error("the AVD has no verified creation configuration");
@@ -720,7 +888,7 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 		}
 		if (existsSync(profile)) removeSingletonFiles(profile);
 		if (deleteProfile && existsSync(profile)) {
-			if (!readCreatedDevices().web.has(profile)) return {
+			if (!readCreatedDevices$1().web.has(profile)) return {
 				status: "skipped",
 				kind: "not-owned",
 				reason: `${profile} is not in Stim's ledger; it was kept`
@@ -743,6 +911,83 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 	}
 }
 //#endregion
+//#region src/macos/instances.ts
+const BUNDLE_EXECUTABLE = /^[^/]+\.app\/Contents\/MacOS\/[^/]+$/;
+function bundleDirs(root) {
+	const dir = macosDir(root);
+	if (process.platform !== "darwin" || !existsSync(dir)) return [];
+	return [.../* @__PURE__ */ new Set([dir, realpathSync(dir)])];
+}
+function isBundleExecutable(path, dirs) {
+	return dirs.some((dir) => path.startsWith(`${dir}/`) && BUNDLE_EXECUTABLE.test(path.slice(dir.length + 1)));
+}
+/** Pids from `ps -axww -o pid=,comm=` output whose command names a bundle executable inside `dirs`. */
+function bundleCandidates(psOutput, dirs) {
+	const pids = [];
+	for (const line of psOutput.split("\n")) {
+		const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+		if (match && isBundleExecutable(match[2], dirs)) pids.push(Number(match[1]));
+	}
+	return pids;
+}
+/** Whether `lsof -Fn -d txt` output for one process names a bundle executable inside `dirs`. */
+function lsofNamesBundleExecutable(lsofOutput, dirs) {
+	return lsofOutput.split("\n").some((line) => line.startsWith("n") && isBundleExecutable(line.slice(1), dirs));
+}
+function candidatePids(dirs) {
+	if (!dirs.length) return [];
+	return bundleCandidates(getExecutor().runFile("ps", [
+		"-axww",
+		"-o",
+		"pid=,comm="
+	], { timeoutMs: 1e4 }), dirs).filter((pid) => pid !== process.pid);
+}
+/** Pids that claim to run an app bundle from the workspace's macOS directory. `ps` reports argv[0], so this is a lead. */
+function bundleInstancePids(root) {
+	return candidatePids(bundleDirs(root));
+}
+function unverified(pid, why) {
+	return Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS app pid ${pid}: ${why}; no signal was sent.`), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+}
+/**
+* Every running process whose executable is an app bundle Stim built in the workspace's macOS directory, however it
+* was launched. Each identity is captured before its executable is confirmed with lsof.
+*/
+function runningBundleInstances(root) {
+	const dirs = bundleDirs(root);
+	const instances = [];
+	for (const pid of candidatePids(dirs)) {
+		const processToken = (0, process_identity_exports.captureProcessToken)(pid);
+		const start = (0, process_identity_exports.processStartMicros)(pid);
+		if (!processToken || start.status !== "running") {
+			if (start.status === "gone") continue;
+			throw unverified(pid, "its identity cannot be captured");
+		}
+		const record = {
+			pid,
+			processToken,
+			startedAtMicros: start.startedAtMicros
+		};
+		let open;
+		try {
+			open = getExecutor().runFile("lsof", [
+				"-a",
+				"-p",
+				String(pid),
+				"-d",
+				"txt",
+				"-Fn"
+			], { timeoutMs: 1e4 });
+		} catch (error) {
+			if (["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(record))) continue;
+			open = String(error.stdout ?? "");
+			if (!open.trim()) throw unverified(pid, `lsof failed (${error.message.split("\n")[0]})`);
+		}
+		if (lsofNamesBundleExecutable(open, dirs)) instances.push(record);
+	}
+	return instances;
+}
+//#endregion
 //#region src/engine/public-http-probe.ts
 const DNS_TIMEOUT_MS = 5e3;
 async function resolveAddresses(hostname, signal) {
@@ -1301,4 +1546,397 @@ function numberOrNull(v) {
 	return typeof v === "number" && Number.isSafeInteger(v) && v > 0 ? v : null;
 }
 //#endregion
-export { teardownParkedAvd as _, terminateChild as a, withManagedTunnelLock as c, eraseParkedAvd as d, eraseParkedIosSim as f, teardownOwnedIosSim as g, teardownOwnedBrowser as h, stopTunnel as i, withManagedTunnelRemovalLock as l, teardownOwnedAvd as m, managedLockHolders as n, withManagedRemoteWorktreeLock as o, teardownBrowserHeld as p, startTunnelSequence as r, withManagedRemoteWorktreeRemovalLock as s, resolveSupervisorTarget as t, probePublicHttp as u, teardownParkedIosSim as v };
+//#region src/workspace/in-use.ts
+const NATIVE_RUN = "native-run";
+const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
+function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted = true, nativeRun = true } = {}) {
+	const reasons = [];
+	if (supervisor) {
+		const project = getProject(root);
+		const target = resolveSupervisorTarget({
+			state: readWorkspaceState$1(root)?.supervisor,
+			record: project?.supervisor,
+			reservedPort: project?.metroPort
+		});
+		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
+		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+		const macos = macosAppState(readMacosRecord(root));
+		if (macos?.host) reasons.push(`its macOS app runs on ${macos.host.machine}`);
+		else if (macos?.state === "running" || macos?.state === "orphaned" || macos?.build.state === "running") reasons.push("its macOS app or build is running");
+		else if (macos?.state === "unverified" || !macos && readWorkspaceState$1(root)?.macos !== void 0) reasons.push("its macOS process owner cannot be verified");
+		else try {
+			const pids = bundleInstancePids(root);
+			if (pids.length) reasons.push(`its macOS app is running (pid ${pids.join(", ")})`);
+		} catch (error) {
+			reasons.push(`its running macOS apps cannot be listed: ${error.message}`);
+		}
+		const runtime = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
+		if (runtime.live.length) reasons.push("its macOS runtime claim is held");
+		else if (runtime.unresolved[0]) reasons.push(`its macOS runtime cannot be verified: ${runtime.unresolved[0].reason}`);
+		const browser = webFacts(readWebRecord(root));
+		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
+		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
+	}
+	if (nativeRun) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
+		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
+		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	for (const platform of ["ios", "android"]) for (const [slot, record] of Object.entries(hosted ? hostedNativeRecords(readWorkspaceState$1(root), platform) : {})) {
+		const placement = parseHostedNativePlacement(record, platform);
+		reasons.push(placement ? `its ${platform === "ios" ? "iOS simulator" : "Android emulator"} runs on ${placement.machine}` : unreadableHostedNative(slot, platform));
+	}
+	const self = canonicalPath(root);
+	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
+		if (!entry.alive && !entry.unresolved) continue;
+		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
+	}
+	if (managedLocks) reasons.push(...managedLockHolders(root));
+	return reasons;
+}
+function emptyWorkspaceDir(dir) {
+	if (lstatSync(dir).isSymbolicLink()) {
+		unlinkSync(dir);
+		return;
+	}
+	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join(dir, name), {
+		recursive: true,
+		force: true
+	});
+}
+async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
+			const reasons = workspaceInUse(root, {
+				...checks,
+				nativeRun: false
+			});
+			if (reasons.length) return {
+				ran: false,
+				reasons
+			};
+			return {
+				ran: true,
+				value: await fn()
+			};
+		}, {
+			external: true,
+			waitMs: 0,
+			ownerPurpose: purpose
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error)) return {
+			ran: false,
+			reasons: [NATIVE_RUN_HELD]
+		};
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
+			ran: false,
+			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
+		};
+		throw error;
+	} finally {
+		try {
+			const dir = workspaceDir(root);
+			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
+		} catch {}
+	}
+}
+//#endregion
+//#region src/commands/gc/workspaces.ts
+function workspacesRoot() {
+	return join$1(getConfigDir(), "workspaces");
+}
+function isInsideWorkspaces(dir) {
+	const rel = relative$1(canonicalPath(workspacesRoot()), canonicalPath(dir));
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute$1(rel);
+}
+function readRecordedRoot(dir, name) {
+	let parsed;
+	try {
+		parsed = readJsonFile(join$1(dir, "workspace.json"));
+	} catch (error) {
+		return {
+			projectRoot: null,
+			problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
+		};
+	}
+	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
+	if (typeof projectRoot !== "string" || !isAbsolute$1(projectRoot)) return {
+		projectRoot: null,
+		problem: "its workspace.json records no absolute project root"
+	};
+	if (workspaceName(projectRoot) !== name) return {
+		projectRoot: null,
+		problem: `its workspace.json records ${projectRoot}, whose workspace directory has another name`
+	};
+	return {
+		projectRoot,
+		problem: null
+	};
+}
+function listWorkspaceDirs() {
+	const root = workspacesRoot();
+	let names;
+	try {
+		names = readdirSync$1(root).toSorted();
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const name of names) {
+		const dir = join$1(root, name);
+		try {
+			if (!statSync$1(dir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		entries.push({
+			dir,
+			...readRecordedRoot(dir, name)
+		});
+	}
+	return entries;
+}
+function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse }) {
+	const orphaned = [];
+	const skipped = [];
+	for (const { dir, projectRoot, problem } of entries) {
+		if (projectRoot === null) {
+			skipped.push({
+				dir,
+				reason: `workspace directory not resolved: ${problem ?? "unknown project root"}`
+			});
+			continue;
+		}
+		const present = exists(projectRoot);
+		if (present === null) {
+			skipped.push({
+				dir,
+				reason: `cannot tell whether its project root ${projectRoot} still exists`
+			});
+			continue;
+		}
+		if (present) continue;
+		if (registryKeys.some((key) => isPathPrefix(projectRoot, key))) continue;
+		if (!isMounted(projectRoot)) {
+			skipped.push({
+				dir,
+				reason: `the volume of its project root ${projectRoot} is not mounted`
+			});
+			continue;
+		}
+		const reasons = inUse(projectRoot);
+		if (reasons.length) {
+			skipped.push({
+				dir,
+				reason: `its project root ${projectRoot} is gone, but ${reasons.join("; ")}`
+			});
+			continue;
+		}
+		orphaned.push({
+			dir,
+			projectRoot
+		});
+	}
+	return {
+		orphaned,
+		skipped
+	};
+}
+function rootPresence(path) {
+	try {
+		lstatSync$1(path);
+		return true;
+	} catch (error) {
+		const code = error?.code;
+		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
+	}
+}
+function collectOrphanedWorkspaces(registryKeys, mountedVolumes, { measure = true } = {}) {
+	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
+		registryKeys,
+		exists: rootPresence,
+		isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
+		inUse: (root) => workspaceInUse(root)
+	});
+	return {
+		orphaned: measure ? classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })) : classified.orphaned,
+		skipped: classified.skipped
+	};
+}
+const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift. The next stim macos in a cleared workspace is a full Swift build.";
+const WORKSPACE_OUTPUT_DIRS = [
+	"derived-data",
+	"gradle-build",
+	"android-cas",
+	"cache-provider"
+];
+const DAY_MS = 864e5;
+function planWorkspaceOutputs(entries, { olderThan, now }) {
+	return entries.map(({ dir, projectRoot, problem, bytes, lastUsed, inUse }) => {
+		const idleDays = Number.isFinite(lastUsed) ? Math.max(0, Math.floor((now - lastUsed) / DAY_MS)) : null;
+		const [keptCode, keptReason] = projectRoot === null ? ["unresolved", `workspace directory not resolved: ${problem ?? "unknown project root"}`] : inUse.length ? ["in-use", `in use: ${inUse.join("; ")}`] : olderThan === null ? [null, null] : idleDays === null ? ["last-use-unknown", "its last use is unknown"] : idleDays < olderThan ? ["recently-used", `used ${idleDays}d ago, within --older-than ${olderThan}`] : [null, null];
+		return {
+			dir,
+			projectRoot,
+			bytes,
+			idleDays,
+			willClear: keptCode === null,
+			keptCode,
+			keptReason
+		};
+	});
+}
+const SIZE_TIMEOUT_MS = 6e4;
+function sizeOf(dir, timeoutMs = SIZE_TIMEOUT_MS) {
+	return measuredDirectorySize(dir, { timeoutMs });
+}
+function outputPaths(dir) {
+	const paths = WORKSPACE_OUTPUT_DIRS.map((name) => join$1(dir, name)).filter((path) => existsSync$1(path));
+	const macos = join$1(dir, "macos");
+	try {
+		if (!lstatSync$1(macos).isDirectory()) return paths;
+		for (const entry of readdirSync$1(macos, { withFileTypes: true })) if (entry.name === "build" || entry.name.endsWith(".app") || entry.name.startsWith("staging-") && entry.isDirectory()) paths.push(join$1(macos, entry.name));
+	} catch {}
+	return paths;
+}
+function outputBytes(paths, timeoutMs) {
+	let total = 0;
+	for (const path of paths) {
+		const size = sizeOf(path, timeoutMs);
+		if (size === null) return null;
+		total += size;
+	}
+	return total;
+}
+function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS }) {
+	const mountedVolumes = listMountedVolumes();
+	const entries = listWorkspaceDirs().filter((entry) => !exclude.includes(entry.dir)).filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => Object.assign({}, entry, { paths: outputPaths(entry.dir) })).filter((entry) => entry.paths.length > 0).map(({ paths, ...entry }) => Object.assign({}, entry, { bytes: measure ? outputBytes(paths, sizeTimeoutMs) : null })).map((entry) => Object.assign({}, entry, {
+		lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
+		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
+	}));
+	return {
+		root: workspacesRoot(),
+		workspaces: planWorkspaceOutputs(entries, {
+			olderThan,
+			now
+		})
+	};
+}
+async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
+	let failures = 0;
+	let cleared = 0;
+	const clearedRoots = [];
+	for (const entry of report.workspaces) {
+		const root = entry.projectRoot;
+		if (!entry.willClear || root === null) {
+			if (entry.keptReason) {
+				console.log(chalk.dim(`Kept the build outputs of ${root ?? entry.dir}: ${entry.keptReason}`));
+				recordGcResult("workspaceOutputs", "kept", root ?? entry.dir, {
+					bytes: entry.bytes,
+					detail: entry.keptReason
+				});
+			}
+			continue;
+		}
+		let run;
+		try {
+			run = await withIdleWorkspace(root, () => {
+				const [again] = planWorkspaceOutputs([{
+					...entry,
+					problem: null,
+					lastUsed: workspaceLastUsed(root),
+					inUse: []
+				}], {
+					olderThan,
+					now
+				});
+				if (again?.keptReason) return again.keptReason;
+				for (const path of outputPaths(entry.dir)) rmSync$1(path, {
+					recursive: true,
+					force: true
+				});
+				return null;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not clear the build outputs of ${root}: ${error?.message || String(error)}`));
+			recordGcResult("workspaceOutputs", "failed", root, {
+				bytes: entry.bytes,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		const kept = run.ran ? run.value : `in use: ${run.reasons.join("; ")}`;
+		if (kept) {
+			console.log(chalk.yellow(`Kept the build outputs of ${root}: ${kept}`));
+			recordGcResult("workspaceOutputs", "kept", root, {
+				bytes: entry.bytes,
+				detail: kept
+			});
+			continue;
+		}
+		cleared += entry.bytes ?? 0;
+		clearedRoots.push(root);
+		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+		recordGcResult("workspaceOutputs", "done", root, { bytes: entry.bytes });
+	}
+	if (cleared) console.log(chalk.dim(`Cleared ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
+	return {
+		failures,
+		cleared: clearedRoots
+	};
+}
+function stillOrphaned({ dir, projectRoot }) {
+	if (readRecordedRoot(dir, basename$1(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
+	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
+}
+async function deleteOrphanedWorkspaces(orphaned) {
+	let failures = 0;
+	for (const entry of orphaned) {
+		if (!existsSync$1(entry.dir)) continue;
+		let run;
+		try {
+			run = await withIdleWorkspace(entry.projectRoot, async () => {
+				if (!stillOrphaned(entry)) return false;
+				const browser = await teardownOwnedBrowser(entry.projectRoot, { deleteProfile: true });
+				if (browser.status === "failed" || browser.status === "skipped") throw new Error(`its owned Chrome profile was kept: ${browser.reason}`);
+				emptyWorkspaceDir(entry.dir);
+				return true;
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
+			recordGcResult("workspaceDirectory", "failed", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: error?.message || String(error)
+			});
+			continue;
+		}
+		if (!run.ran) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: run.reasons.join("; ")
+			});
+			continue;
+		}
+		if (!run.value) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
+			recordGcResult("workspaceDirectory", "kept", entry.dir, {
+				bytes: entry.bytes ?? null,
+				detail: "it can no longer be confirmed orphaned"
+			});
+			continue;
+		}
+		const size = entry.bytes === void 0 ? "" : ` (${sizeText(entry.bytes)})`;
+		console.log(chalk.green(`Removed the orphaned workspace directory ${entry.dir}${size}`));
+		recordGcResult("workspaceDirectory", "done", entry.dir, { bytes: entry.bytes ?? null });
+	}
+	return failures;
+}
+function sizeText(bytes) {
+	return bytes === null ? "size unknown" : formatBytes(bytes);
+}
+//#endregion
+export { teardownParkedAvd as A, runningBundleInstances as C, teardownOwnedAvd as D, teardownBrowserHeld as E, recordGcResult as F, takeGcResults as I, canonicalPath as L, acquireBuildSlot as M, listBuildSlots as N, teardownOwnedBrowser as O, releaseBuildSlot as P, probePublicHttp as S, eraseParkedIosSim as T, terminateChild as _, collectWorkspaceOutputs as a, withManagedTunnelLock as b, listWorkspaceDirs as c, emptyWorkspaceDir as d, withIdleWorkspace as f, stopTunnel as g, startTunnelSequence as h, collectOrphanedWorkspaces as i, teardownParkedIosSim as j, teardownOwnedIosSim as k, rootPresence as l, resolveSupervisorTarget as m, WORKSPACE_OUTPUT_DIRS as n, deleteOrphanedWorkspaces as o, workspaceInUse as p, clearWorkspaceOutputs as r, isInsideWorkspaces as s, REBUILD_COST as t, sizeText as u, withManagedRemoteWorktreeLock as v, eraseParkedAvd as w, withManagedTunnelRemovalLock as x, withManagedRemoteWorktreeRemovalLock as y };