stim 1.17.2 → 1.18.0

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

@@ -1,25 +1,192 @@
-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-DWhCZDGm.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-CBtzyIgF.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-CgYMahz7.mjs";
+import { y as repoRoot } from "./worktree-CsKYexJM.mjs";
+import { o as pidExists, u as signalProcessTree } from "./metro-Dh8T4Ytd.mjs";
+import { S as workspaceName, g as workspaceAgentDeviceDir, r as readWorkspaceState$1, s as workspaceLastUsed, v as workspaceDir } from "./workspace-state-C59dqG-Z.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-BG-aAk4k.mjs";
+import { t as agentDeviceDaemon, u as readAgentDeviceRecords } from "./activity-BxnkDZDi.mjs";
+import { h as listBuildLocks } from "./device-lease-Co-EwifR.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-DKbeWsiK.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-DC3ZLuw0.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-B3SbOWdw.mjs";
+import { J as resolveTailscaleBinary } from "./settings-CQyMElEP.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError, r as releaseBrowserPort, s as workspaceProcessLockPath } from "./named-ports-BFIz1Shz.mjs";
+import { i as macosRuntimeClaim } from "./state-xnqpx3AD.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, 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 }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const started = now();
+	let lastProgress = started;
+	let waited = false;
+	try {
+		for (;;) {
+			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 +559,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 +572,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 +648,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 +714,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 +730,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 +887,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`
@@ -1301,4 +1468,391 @@ 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");
+		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 { teardownParkedIosSim as A, eraseParkedAvd as C, teardownOwnedBrowser as D, teardownOwnedAvd as E, takeGcResults as F, canonicalPath as I, listBuildSlots as M, releaseBuildSlot as N, teardownOwnedIosSim as O, recordGcResult as P, probePublicHttp as S, teardownBrowserHeld 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, acquireBuildSlot as j, teardownParkedAvd 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, eraseParkedIosSim as w, withManagedTunnelRemovalLock as x, withManagedRemoteWorktreeRemovalLock as y };

package/dist/{worktree-j3IcFAI5.mjs → worktree-BJfnU6r5.mjs}

@@ -1,2 +1,2 @@
-import { a as porcelainPath, c as registerWarm, d as removalRemedy, f as removeWorktreeTarget, i as matchWorktreeEntry, l as removalBlockers, m as worktreeCommand, n as excludePodChurn, o as reclaimKeys, p as warmedWorkspace, r as excludeWatchmanCookies, s as registerRemove, t as dependencyInstallCommand, u as removalPath } from "./worktree-Be_7NLKy.mjs";
+import { a as porcelainPath, c as registerWarm, d as removalRemedy, f as removeWorktreeTarget, i as matchWorktreeEntry, l as removalBlockers, m as worktreeCommand, n as excludePodChurn, o as reclaimKeys, p as warmedWorkspace, r as excludeWatchmanCookies, s as registerRemove, t as dependencyInstallCommand, u as removalPath } from "./worktree-BSYlofkq.mjs";
 export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, excludeWatchmanCookies, matchWorktreeEntry, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget, warmedWorkspace };