stim 1.21.0 → 1.23.0

package/dist/{workspaces-BccMFmGQ.mjs → workspaces-BxzYlo3P.mjs}

@@ -1,20 +1,20 @@
-import { c as stopDeclaringSpawnsOn, f as ownership_claim_exports, i as declareSpawnsOn, p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { a as workspaceProcessLockError, c as declareSpawnsOn, f as stopDeclaringSpawnsOn, g as process_identity_exports, i as withWorkspaceProcessLock, o as workspaceProcessLockPath, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
 import { d as workspaceDir, h as workspaceName$1, l as workspaceAgentDeviceDir } from "./paths-DQtTgsBf.mjs";
-import { D as withConfigLock$1, F as isOnMountedVolume, I as listMountedVolumes, K as projectDeviceSlots, O as withConfigLockAsync$1, P as formatBytes, R as measuredDirectorySizeAsync, U as deviceSlotPlatforms, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix, j as acquireAvdClaim, p as getProject } from "./config-CYcBF478.mjs";
+import { F as isOnMountedVolume, G as projectDeviceSlots, H as deviceSlotPlatforms, I as listMountedVolumes, L as measuredDirectorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, _ as loadConfig$1, d as getConfigDir, g as isPathPrefix, j as acquireAvdClaim, p as getProject } from "./config-DlrsduwG.mjs";
 import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-B1UrjZHL.mjs";
-import { l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-Cjuigeeu.mjs";
-import { It as repoRootAsync, Qt as cancellableSleep, en as throwIfCancelled, ut as resolveTailscaleBinary } from "./settings-CsJDEXgK.mjs";
-import { a as macosRuntimeClaim, n as macosDir } from "./state-XMziexv2.mjs";
-import { l as pidExists, m as signalProcessTreeAsync, p as signalProcessTree } from "./metro-DEXpIhHC.mjs";
-import { _ as chromeProcessStateAsync, c as webClaimRoot, i as clearWebRecord, o as readWebRecord, p as webProfileDir, t as CDP_PORT_LABEL, u as webFacts, v as liveProfileHolder, y as removeSingletonFiles } from "./state-C4ZtUisW.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-Db8BqzxH.mjs";
+import { f as throwIfCancelled, t as runOperationFile, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-U08dEzhG.mjs";
+import { Nt as repoRootAsync, ut as resolveTailscaleBinary } from "./settings-C7O8A6ZI.mjs";
+import { a as macosRuntimeClaim, n as macosDir } from "./state-08I3hw3_.mjs";
+import { c as pidExists, f as signalProcessTree, p as signalProcessTreeAsync } from "./metro-DiXtA3Ty.mjs";
+import { _ as chromeProcessStateAsync, c as webClaimRoot, i as clearWebRecord, o as readWebRecord, p as webProfileDir, t as CDP_PORT_LABEL, u as webFacts, v as liveProfileHolder, y as removeSingletonFiles } from "./state--smjFSTL.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { N as listBuildLocks, d as readAgentDeviceRecords, t as agentDeviceDaemon } from "./activity-BzVfHSrY.mjs";
-import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-CqeBlrEn.mjs";
-import { A as listAdbDevicesAsync, B as ownedAvdMatchesConfiguration, F as listOrphanedAvdDirectories, Q as resolveOwnedAvdSerialAsync, W as ownedAvdSystemImage, _ as avdStorageRoots, _t as removeParkedAfter, at as wipeAvdUserData, et as shutdownAndroidEmulator, f as assertOwnedAvdStopped, ft as eraseParkedAfter, gt as readParked, h as avdPathExists, mt as parkSim, rt as waitForAndroidEmulatorShutdown, st as isStimOwnedAvd, x as deleteAvd, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
-import { E as resolveOwnedIosSim, O as shutdownIosSim, S as renameIosSim, c as eraseIosSim, f as listAllIosSimsAsync, o as deleteIosSim, p as listIosDeviceTypesAsync, s as deleteParkedIosSim, v as parkedSimName, y as parseRuntimeVersion } from "./ios-CpByZy12.mjs";
-import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
-import { r as releaseBrowserPort } from "./named-ports-BWTzt6mu.mjs";
+import { N as listBuildLocks, d as readAgentDeviceRecords, t as agentDeviceDaemon } from "./activity-B5RtpFda.mjs";
+import { i as recordCreatedDevice, r as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-x9rN6bhs.mjs";
+import { H as ownedAvdMatchesConfiguration, K as ownedAvdSystemImage, L as listOrphanedAvdDirectories, S as deleteAvd, V as ownedAvdDirectory, at as waitForAndroidEmulatorShutdown, et as resolveOwnedAvdSerialAsync, g as avdPathExists, gt as parkSim, j as listAdbDevicesAsync, lt as isStimOwnedAvd, mt as eraseParkedAfter, nt as shutdownAndroidEmulator, p as assertOwnedAvdStoppedAsync, st as wipeAvdUserData, v as avdStorageRoots, vt as readParked, yt as removeParkedAfter } from "./android-C7sVmyI9.mjs";
+import { E as resolveOwnedIosSim, O as shutdownIosSim, S as renameIosSim, c as eraseIosSim, f as listAllIosSimsAsync, o as deleteIosSim, p as listIosDeviceTypesAsync, s as deleteParkedIosSim, v as parkedSimName, y as parseRuntimeVersion } from "./ios-hcBpnEGk.mjs";
+import { r as releaseBrowserPort } from "./named-ports-DkEzOfzO.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
@@ -24,26 +24,35 @@ import { ambientContext, ambientEnv, ambientWrite } from "@stim-cli/core";
 import { buildSlotsDir, hostedNativeRecords, isJsonObject, macosAppState, parseHostedNativePlacement, readJsonFile, readMacosRecord, requireAutomaticMachine, tryAcquireBuildSlotClaim, unreadableHostedNative } from "@stim-cli/core/state";
 import { basename as basename$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1 } from "path";
 import chalk from "chalk";
-import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
+import { lstat, readFile, readdir, rm, stat, unlink } from "node:fs/promises";
 import { resolve4 } from "node:dns/promises";
 import { request } from "node:https";
 //#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);
+function createGcResults() {
+	const results = [];
+	return {
+		record(kind, status, label, { id = null, bytes = null, detail = null } = {}) {
+			results.push({
+				kind,
+				status,
+				label,
+				id,
+				bytes,
+				detail
+			});
+		},
+		take() {
+			return results.splice(0);
+		}
+	};
 }
+const detachedResults = createGcResults();
+const recordGcResult = detachedResults.record;
+const takeGcResults = detachedResults.take;
 const GC_OUTPUT = {
 	log: (line) => console.log(line),
+	error: (line) => console.error(line),
 	record: recordGcResult,
 	fail: () => {
 		process.exitCode = 1;
@@ -205,12 +214,18 @@ function parseDu(output) {
 	}
 	return sizes;
 }
-async function measureDu(args) {
+async function measureDu(args, operation) {
 	let output = "";
 	let complete = true;
 	try {
-		output = await getExecutor().runFileAsync("du", args, { timeoutMs: 2e4 });
+		output = await runOperationFile(operation, getExecutor(), "du", args, {
+			timeoutMs: 2e4,
+			cwd: operation?.cwd,
+			signal: operation?.signal
+		});
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		complete = false;
 		const failure = error;
 		if (failure.status === 1 && !failure.code && typeof failure.stdout === "string") output = failure.stdout;
@@ -349,9 +364,10 @@ function explainFailure(error) {
 function report(message) {
 	ambientWrite("stderr", `${phaseLine("device", message)}\n`);
 }
-async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot) {
+async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot, operation) {
 	const exec = getExecutor();
 	try {
+		operation?.signal.throwIfAborted();
 		if (!exec.findExecutable("agent-device")) return;
 		const root = workspace === void 0 ? void 0 : canonical(workspace);
 		if (root === null) return;
@@ -368,7 +384,7 @@ async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot)
 				const remaining = deadline - Date.now();
 				if (remaining <= 0) throw new Error("agent-device cleanup timed out");
 				try {
-					return await exec.runFileAsync("agent-device", [
+					return await runOperationFile(operation, exec, "agent-device", [
 						...args,
 						...dir ? ["--state-dir", dir] : [],
 						"--json",
@@ -379,6 +395,8 @@ async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot)
 						killSignal: "SIGKILL"
 					});
 				} catch (error) {
+					if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+					operation?.signal.throwIfAborted();
 					throw explainFailure(error);
 				}
 			};
@@ -406,27 +424,35 @@ async function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot)
 					]))?.success !== true) throw new Error("agent-device did not confirm session close");
 					report(`closed agent-device session ${session.name} on ${session.id}`);
 				} catch (error) {
+					if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+					operation?.signal.throwIfAborted();
 					report(`could not close agent-device session ${session.name} on ${session.id}: ${error.message}`);
 				}
 			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+				operation?.signal.throwIfAborted();
 				report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
 			}
 		}
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
 	}
 }
 //#endregion
 //#region src/devices/teardown.ts
-async function teardownParkedAvd(avdName) {
+async function teardownParkedAvd(avdName, { operation } = {}) {
 	try {
+		operation?.signal.throwIfAborted();
 		return await removeParkedAfter("android", avdName, async () => {
 			const result = await teardownOwnedAvd(avdName, {
 				del: true,
-				owner: { pool: true }
+				owner: { pool: true },
+				operation
 			});
 			if (result.status !== "torn-down" && result.status !== "missing") throw new Error(result.reason);
-		}) ? {
+		}, operation) ? {
 			status: "torn-down",
 			label: avdName
 		} : {
@@ -435,21 +461,24 @@ async function teardownParkedAvd(avdName) {
 			reason: "emulator is no longer parked"
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
 		};
 	}
 }
-async function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSim } = {}) {
+async function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSim, operation } = {}) {
 	try {
+		operation?.signal.throwIfAborted();
 		const removed = await removeParkedAfter("ios", udid, async () => {
 			await closeOwnedDeviceSessions({
 				platform: "ios",
 				id: udid
-			}, async () => Boolean((await resolveOwnedIosSimNow(udid)).sim));
-			await deleteSim(udid);
-		});
+			}, async () => Boolean((await resolveOwnedIosSimNow(udid, operation)).sim), void 0, void 0, operation);
+			await deleteSim(udid, operation);
+		}, operation);
 		if (!removed) return {
 			status: "skipped",
 			kind: "not-parked",
@@ -460,27 +489,34 @@ async function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSi
 			label: label ?? removed.name
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
 		};
 	}
 }
-async function eraseParkedIosSim(udid, { label } = {}) {
+async function eraseParkedIosSim(udid, { label, operation } = {}) {
 	try {
+		operation?.signal.throwIfAborted();
 		const erased = await eraseParkedAfter("ios", udid, async (_record, eraseStarted) => {
 			await closeOwnedDeviceSessions({
 				platform: "ios",
 				id: udid
-			}, async () => Boolean((await resolveOwnedIosSimNow(udid)).sim));
-			const resolved = resolveOwnedIosSim(udid, await listAllIosSimsAsync());
+			}, async () => Boolean((await resolveOwnedIosSimNow(udid, operation)).sim), void 0, void 0, operation);
+			const resolved = resolveOwnedIosSim(udid, await listAllIosSimsAsync({
+				signal: operation?.signal,
+				operation
+			}));
 			if (resolved.missing) throw new Error(`simulator ${udid} is not on this machine`);
 			if (resolved.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(resolved.notOwned)}`);
 			const state = resolved.sim.state;
 			if (state !== "Shutdown") throw new Error(`simulator ${udid} is ${state}, not Shutdown; it was kept`);
+			operation?.signal.throwIfAborted();
 			eraseStarted();
-			await eraseIosSim(udid);
-		});
+			await eraseIosSim(udid, operation);
+		}, operation);
 		if (!erased) return {
 			status: "skipped",
 			kind: "not-parked",
@@ -491,23 +527,31 @@ async function eraseParkedIosSim(udid, { label } = {}) {
 			label: label ?? erased.name
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
 		};
 	}
 }
-async function eraseParkedAvd(avdName) {
+async function eraseParkedAvd(avdName, { operation } = {}) {
 	try {
+		operation?.signal.throwIfAborted();
 		return await eraseParkedAfter("android", avdName, async (_record, eraseStarted) => {
-			if ((await resolveOwnedAvdSerialAsync(avdName, { timeoutMs: AVD_INVENTORY_TIMEOUT_MS })).serial) throw new Error(`AVD ${avdName} is running; it was kept`);
+			if ((await resolveOwnedAvdSerialAsync(avdName, {
+				timeoutMs: AVD_INVENTORY_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			})).serial) throw new Error(`AVD ${avdName} is running; it was kept`);
 			const result = await teardownOwnedAvd(avdName, {
 				wipe: true,
 				owner: { pool: true },
-				onWipeStart: eraseStarted
+				onWipeStart: eraseStarted,
+				operation
 			});
 			if (result.status !== "torn-down") throw new Error(result.reason ?? `AVD ${avdName} is ${result.status}`);
-		}) ? {
+		}, operation) ? {
 			status: "torn-down",
 			label: avdName
 		} : {
@@ -516,6 +560,8 @@ async function eraseParkedAvd(avdName) {
 			reason: "emulator is no longer parked"
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
@@ -525,9 +571,13 @@ async function eraseParkedAvd(avdName) {
 const IOS_SHUTDOWN_SETTLE_MS = 15e3;
 const ADB_RELEASE_WAIT_MS = 3e3;
 const AVD_INVENTORY_TIMEOUT_MS = 15e3;
-async function repoRootAbove(workspace) {
+async function repoRootAbove(workspace, operation) {
 	if (workspace === void 0 || !getExecutor().findExecutable("agent-device")) return void 0;
-	const root = await repoRootAsync(workspace);
+	const root = await repoRootAsync(workspace, {
+		declareFor: operation,
+		env: operation?.env,
+		signal: operation?.signal
+	});
 	try {
 		return root && realpathSync(root) !== realpathSync(workspace) ? root : void 0;
 	} catch {
@@ -536,37 +586,49 @@ async function repoRootAbove(workspace) {
 }
 const IOS_SHUTDOWN_POLL_MS = 250;
 const IOS_SHUTDOWN_ATTEMPTS = 2;
-async function resolveOwnedIosSimNow(udid) {
-	return resolveOwnedIosSim(udid, await listAllIosSimsAsync());
+async function resolveOwnedIosSimNow(udid, operation) {
+	operation?.signal.throwIfAborted();
+	const sims = await listAllIosSimsAsync({
+		operation,
+		signal: operation?.signal
+	});
+	operation?.signal.throwIfAborted();
+	return resolveOwnedIosSim(udid, sims);
 }
-async function settleIosSimShutdown(udid, { now = Date.now, sleep = sleepAsync }) {
-	let resolved = await resolveOwnedIosSimNow(udid);
+async function settleIosSimShutdown(udid, { now = Date.now, sleep }, operation) {
+	let resolved = await resolveOwnedIosSimNow(udid, operation);
 	for (let attempt = 1;; attempt++) {
 		const deadline = now() + IOS_SHUTDOWN_SETTLE_MS;
 		while (resolved.sim && resolved.sim.state !== "Shutdown" && now() < deadline) {
-			await sleep(IOS_SHUTDOWN_POLL_MS);
-			resolved = await resolveOwnedIosSimNow(udid);
+			await (sleep ? sleep(IOS_SHUTDOWN_POLL_MS) : cancellableSleep(IOS_SHUTDOWN_POLL_MS, {
+				signal: operation?.signal,
+				what: "simulator shutdown"
+			}));
+			resolved = await resolveOwnedIosSimNow(udid, operation);
 		}
 		if (!resolved.sim || resolved.sim.state === "Shutdown" || attempt === IOS_SHUTDOWN_ATTEMPTS) return resolved;
-		await shutdownIosSim(udid);
-		resolved = await resolveOwnedIosSimNow(udid);
+		await shutdownIosSim(udid, operation);
+		resolved = await resolveOwnedIosSimNow(udid, operation);
 	}
 }
 function iosShutdownFailureReason(udid, state) {
 	return `simulator ${udid} is still ${state} after ${IOS_SHUTDOWN_ATTEMPTS} shutdown attempts and ${IOS_SHUTDOWN_ATTEMPTS * IOS_SHUTDOWN_SETTLE_MS / 1e3}s of waiting`;
 }
-async function parkOwnedIosSim(settled, udid, park) {
+async function parkOwnedIosSim(settled, udid, park, operation) {
 	if (settled.missing) throw new Error(`simulator ${udid} disappeared after shutdown`);
 	if (settled.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(settled.notOwned)}`);
 	const sim = settled.sim;
 	if (sim.state !== "Shutdown") throw new Error(iosShutdownFailureReason(udid, sim.state));
-	const model = (await listIosDeviceTypesAsync()).find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null;
+	const model = (await listIosDeviceTypesAsync({
+		operation,
+		signal: operation?.signal
+	})).find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null;
 	const runtime = parseRuntimeVersion(sim.runtime);
 	const name = parkedSimName(sim.udid, {
 		model,
 		runtime
 	});
-	await renameIosSim(sim.udid, name);
+	await renameIosSim(sim.udid, name, operation);
 	const record = {
 		udid: sim.udid,
 		name,
@@ -588,10 +650,10 @@ async function parkOwnedIosSim(settled, udid, park) {
 		})
 	};
 }
-async function teardownOwnedIosSim(udid, { del = false, label, park, workspace, shutdownClock = {} } = {}) {
+async function teardownOwnedIosSim(udid, { del = false, label, park, workspace, shutdownClock = {}, operation } = {}) {
 	let parkFallback;
 	try {
-		const resolved = await resolveOwnedIosSimNow(udid);
+		const resolved = await resolveOwnedIosSimNow(udid, operation);
 		if (resolved.notOwned) return {
 			status: "skipped",
 			kind: "not-owned",
@@ -601,22 +663,25 @@ async function teardownOwnedIosSim(udid, { del = false, label, park, workspace,
 		await closeOwnedDeviceSessions({
 			platform: "ios",
 			id: udid
-		}, async () => Boolean((await resolveOwnedIosSimNow(udid)).sim), workspace);
-		const current = await resolveOwnedIosSimNow(udid);
+		}, async () => Boolean((await resolveOwnedIosSimNow(udid, operation)).sim), workspace, void 0, operation);
+		const current = await resolveOwnedIosSimNow(udid, operation);
 		if (current.missing) return { status: "missing" };
 		if (current.notOwned) return {
 			status: "skipped",
 			kind: "not-owned",
 			reason: "simulator ownership changed before shutdown"
 		};
-		await shutdownIosSim(udid);
+		await shutdownIosSim(udid, operation);
 		const sim = resolved.sim;
 		if (del && park && park.max > 0) try {
-			const { record, evicted } = await parkOwnedIosSim(await settleIosSimShutdown(udid, shutdownClock), udid, park);
+			const { record, evicted } = await parkOwnedIosSim(await settleIosSimShutdown(udid, shutdownClock, operation), udid, park, operation);
 			const removed = [];
 			const failures = [];
 			for (const entry of evicted) {
-				const result = await teardownParkedIosSim(entry.udid, { label: entry.name });
+				const result = await teardownParkedIosSim(entry.udid, {
+					label: entry.name,
+					operation
+				});
 				if (result.status === "torn-down") removed.push({
 					udid: entry.udid,
 					name: entry.name
@@ -634,32 +699,36 @@ async function teardownOwnedIosSim(udid, { del = false, label, park, workspace,
 				...failures.length ? { evictionFailures: failures } : {}
 			};
 		} catch (e) {
+			if (e instanceof WorkspaceProcessCleanupError) throw e;
+			operation?.signal.throwIfAborted();
 			parkFallback = String(e?.message || e);
 		}
 		if (del) {
-			await deleteIosSim(udid);
+			await deleteIosSim(udid, operation);
 			return {
 				status: "torn-down",
 				label: label ?? sim.name ?? udid,
 				...parkFallback ? { parkFallback } : {}
 			};
 		}
-		const settled = await settleIosSimShutdown(udid, shutdownClock);
+		const settled = await settleIosSimShutdown(udid, shutdownClock, operation);
 		if (settled.sim && settled.sim.state !== "Shutdown") return {
 			status: "failed",
 			label: label ?? sim.name ?? udid,
 			reason: iosShutdownFailureReason(udid, settled.sim.state)
 		};
-		const root = sim.state === "Shutdown" ? void 0 : await repoRootAbove(workspace);
+		const root = sim.state === "Shutdown" ? void 0 : await repoRootAbove(workspace, operation);
 		if (root && settled.sim) await closeOwnedDeviceSessions({
 			platform: "ios",
 			id: udid
-		}, async () => (await resolveOwnedIosSimNow(udid)).sim?.state === "Shutdown", workspace, root);
+		}, async () => (await resolveOwnedIosSimNow(udid, operation)).sim?.state === "Shutdown", workspace, root, operation);
 		return {
 			status: "torn-down",
 			label: label ?? sim.name ?? udid
 		};
 	} catch (e) {
+		if (e instanceof WorkspaceProcessCleanupError) throw e;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(e?.message || e),
@@ -677,11 +746,12 @@ function assertAvdReferences(avdName, owner) {
 	}
 	if (readParked("android", { config }).some((entry) => entry.name.toLowerCase() === avdName.toLowerCase()) && !(owner && "pool" in owner)) throw new Error(`AVD ${avdName} is in the emulator pool; its data was kept.`);
 }
-function removeOrphanedAvdDirectory(candidate, owner) {
+async function removeOrphanedAvdDirectory(candidate, owner, operation) {
+	operation?.signal.throwIfAborted();
 	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$1(() => {
+	await assertOwnedAvdStoppedAsync(candidate.name, operation, () => candidate.directory);
+	const detached = await withConfigLockAsync$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);
@@ -696,17 +766,19 @@ function removeOrphanedAvdDirectory(candidate, owner) {
 		}
 		forgetCreatedDevice("android", candidate.name);
 		return destination;
-	});
+	}, operation?.signal);
 	const current = lstatSync(detached);
 	if (!current.isDirectory() || current.dev !== candidate.dev || current.ino !== candidate.ino) throw new Error(`Detached AVD data changed at ${detached}; it was kept.`);
+	operation?.signal.throwIfAborted();
 	try {
-		rmSync(detached, { recursive: true });
+		await rm(detached, { recursive: true });
 	} catch (error) {
 		throw new Error(`Could not remove AVD data at ${detached}; retry gc --delete: ${error.message}`, { cause: error });
 	}
 	forgetCreatedDevice("android", basename(detached, ".avd"));
 }
-function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
+async function teardownUnregisteredAvd(avdName, del, owner, surveyed, operation) {
+	operation?.signal.throwIfAborted();
 	const candidates = surveyed ? [surveyed] : listOrphanedAvdDirectories(avdName);
 	if (candidates.length === 0) {
 		if (avdStorageRoots().some((root) => avdPathExists(join(root, `${avdName}.ini`)) || avdPathExists(join(root, `${avdName}.avd`)))) throw new Error(`AVD ${avdName} is not listed but its storage remains; it was kept.`);
@@ -718,7 +790,7 @@ function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
 	};
 	for (const candidate of candidates) {
 		if (candidate.name !== avdName) throw new Error(`AVD data does not match ${avdName}; it was kept.`);
-		removeOrphanedAvdDirectory(candidate, owner);
+		await removeOrphanedAvdDirectory(candidate, owner, operation);
 	}
 	return {
 		status: "torn-down",
@@ -727,37 +799,65 @@ function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
 }
 async function teardownOwnedAvd(avdName, options = {}) {
 	let claim;
+	let retained = false;
+	const operation = options.operation;
 	try {
+		operation?.signal.throwIfAborted();
 		if (!isStimOwnedAvd(avdName)) return {
 			status: "skipped",
 			kind: "not-owned",
 			reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
 		};
 		claim = acquireAvdClaim(avdName);
+		if (operation) declareSpawnsOn(operation, claim);
 		const result = await teardownClaimedAvd(avdName, claim, options);
+		operation?.signal.throwIfAborted();
 		if (result.status === "torn-down" || result.status === "missing") options.onRemoved?.();
 		return result;
 	} catch (error) {
+		if (claim && (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error)) {
+			retained = true;
+			throw Object.assign(new WorkspaceProcessCleanupError([.../* @__PURE__ */ new Set([claim, ...error instanceof WorkspaceProcessCleanupError ? error.claims : []])], error.message, "Verify the AVD operation and its descendants have stopped."), { reportCleanup: true });
+		}
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
 		};
 	} finally {
-		(0, ownership_claim_exports.releaseClaim)(claim);
+		if (operation) stopDeclaringSpawnsOn(operation, claim);
+		if (!retained) (0, ownership_claim_exports.releaseClaim)(claim);
 	}
 }
-async function serialFree(serial, timeoutMs = AVD_INVENTORY_TIMEOUT_MS) {
-	const adb = await listAdbDevicesAsync({ timeoutMs });
+async function serialFree(serial, timeoutMs = AVD_INVENTORY_TIMEOUT_MS, operation) {
+	operation?.signal.throwIfAborted();
+	const adb = await listAdbDevicesAsync({
+		timeoutMs,
+		operation,
+		signal: operation?.signal
+	});
+	operation?.signal.throwIfAborted();
 	return ![
 		...adb.emulators,
 		...adb.physical,
 		...adb.unhealthy
 	].some((entry) => entry.serial === serial);
 }
-async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, park, owner, workspace, orphanedDirectory, onlyIfMissing = false, onWipeStart, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = assertOwnedAvdStopped, resolveAvd = (name) => resolveOwnedAvdSerialAsync(name, { timeoutMs: AVD_INVENTORY_TIMEOUT_MS }) }) {
+async function teardownClaimedAvd(avdName, claim, { operation, del = false, wipe = false, park, owner, workspace, orphanedDirectory, onlyIfMissing = false, onWipeStart, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = (name) => assertOwnedAvdStoppedAsync(name, operation), resolveAvd: resolve = (name) => resolveOwnedAvdSerialAsync(name, {
+	timeoutMs: AVD_INVENTORY_TIMEOUT_MS,
+	operation,
+	signal: operation?.signal
+}) }) {
 	let parkFallback;
+	const resolveAvd = async (name) => {
+		operation?.signal.throwIfAborted();
+		const result = await resolve(name);
+		operation?.signal.throwIfAborted();
+		return result;
+	};
 	try {
-		if (del || wipe) await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner));
+		operation?.signal.throwIfAborted();
+		if (del || wipe) await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner), operation?.signal);
 		const resolved = await resolveAvd(avdName);
 		if (resolved.notOwned) return {
 			status: "skipped",
@@ -766,7 +866,7 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 		};
 		if (resolved.missing) {
 			if (wipe) throw new Error(`AVD ${avdName} is not registered; its data was kept.`);
-			return teardownUnregisteredAvd(avdName, del, owner, orphanedDirectory);
+			return await teardownUnregisteredAvd(avdName, del, owner, orphanedDirectory, operation);
 		}
 		if (onlyIfMissing) return {
 			status: "skipped",
@@ -779,7 +879,7 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 		const serial = resolved.serial;
 		const stillStopped = async (sessionSerial) => {
 			const current = await resolveAvd(avdName);
-			return !current.notOwned && !current.missing && !current.serial && await serialFree(sessionSerial);
+			return !current.notOwned && !current.missing && !current.serial && await serialFree(sessionSerial, AVD_INVENTORY_TIMEOUT_MS, operation);
 		};
 		if (serial) {
 			const stillOwned = async () => {
@@ -790,44 +890,48 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 				platform: "android",
 				id: serial,
 				avdName
-			}, stillOwned, workspace);
+			}, stillOwned, workspace, void 0, operation);
 			if (!await stillOwned()) throw new Error(`Owned AVD ${avdName} changed before shutdown; it was kept.`);
 			await waitForShutdown(avdName, async (timeoutMs) => {
-				(0, ownership_claim_exports.markClaimChildPending)(claim);
+				if (!operation) (0, ownership_claim_exports.markClaimChildPending)(claim);
 				try {
-					await shutdownAndroidEmulator(serial, timeoutMs);
+					await shutdownAndroidEmulator(serial, timeoutMs, operation);
 				} finally {
-					(0, ownership_claim_exports.clearClaimChild)(claim);
+					if (!operation) (0, ownership_claim_exports.clearClaimChild)(claim);
 				}
-			});
-			const root = await repoRootAbove(workspace);
+			}, { operation });
+			const root = await repoRootAbove(workspace, operation);
 			if (root) {
 				const deadline = Date.now() + ADB_RELEASE_WAIT_MS;
-				while (!await serialFree(serial, Math.max(1, deadline - Date.now())) && Date.now() < deadline) await sleepAsync(250);
+				while (!await serialFree(serial, Math.max(1, deadline - Date.now()), operation) && Date.now() < deadline) await cancellableSleep(250, {
+					signal: operation?.signal,
+					what: "emulator release"
+				});
 				await closeOwnedDeviceSessions({
 					platform: "android",
 					id: serial,
 					avdName
-				}, stillStopped, workspace, root);
+				}, stillStopped, workspace, root, operation);
 			}
 		} else {
 			await closeOwnedDeviceSessions({
 				platform: "android",
 				id: null,
 				avdName
-			}, stillStopped, workspace);
-			await waitForShutdown(avdName, null);
+			}, stillStopped, workspace, void 0, operation);
+			await waitForShutdown(avdName, null, { operation });
 		}
 		if (wipe && !del) {
 			const current = await resolveAvd(avdName);
 			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);
-			await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner));
+			await assertStopped(avdName);
+			await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner), operation?.signal);
+			operation?.signal.throwIfAborted();
 			const directory = ownedAvdDirectory(avdName);
 			if (!directory) throw new Error(`The data directory of AVD ${avdName} could not be resolved.`);
 			onWipeStart?.();
-			wipeAvdUserData(directory);
+			await wipeAvdUserData(directory, operation?.signal);
 		}
 		if (del) {
 			const current = await resolveAvd(avdName);
@@ -836,10 +940,11 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 				kind: "not-owned",
 				reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
 			};
-			if (current.missing) return teardownUnregisteredAvd(avdName, del, owner);
+			if (current.missing) return await teardownUnregisteredAvd(avdName, del, owner, void 0, operation);
 			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before deletion.`);
-			assertStopped(avdName);
-			await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner));
+			await assertStopped(avdName);
+			await withConfigLockAsync$1(() => assertAvdReferences(avdName, owner), operation?.signal);
+			operation?.signal.throwIfAborted();
 			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");
@@ -861,7 +966,7 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 				const removed = [];
 				const failures = [];
 				for (const entry of evicted) {
-					const result = await teardownParkedAvd(entry.name);
+					const result = await teardownParkedAvd(entry.name, { operation });
 					if (result.status === "torn-down") removed.push({
 						udid: entry.name,
 						name: entry.name,
@@ -881,16 +986,18 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 					...failures.length ? { evictionFailures: failures } : {}
 				};
 			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError) throw error;
+				operation?.signal.throwIfAborted();
 				parkFallback = String(error?.message || error);
 			}
 			const directory = ownedAvdDirectory(avdName);
 			const paths = avdStorageRoots().map((root) => join(root, `${avdName}.ini`));
 			if (directory) paths.push(directory);
-			(0, ownership_claim_exports.markClaimChildPending)(claim);
+			if (!operation) (0, ownership_claim_exports.markClaimChildPending)(claim);
 			try {
-				await deleteAvd(avdName);
+				await deleteAvd(avdName, operation);
 			} finally {
-				(0, ownership_claim_exports.clearClaimChild)(claim);
+				if (!operation) (0, ownership_claim_exports.clearClaimChild)(claim);
 			}
 			const remaining = paths.filter(avdPathExists);
 			if (remaining.length) throw new Error(`AVD ${avdName} was only partially deleted; data remains at ${remaining.join(", ")}.`);
@@ -902,6 +1009,8 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 			...parkFallback ? { parkFallback } : {}
 		};
 	} catch (e) {
+		if (e instanceof WorkspaceProcessCleanupError) throw e;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(e?.message || e)
@@ -910,20 +1019,29 @@ async function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, p
 }
 const BROWSER_EXIT_WAIT_MS = 15e3;
 const CHROME_KILL_WAIT_MS = 5e3;
-async function stopOwnedChrome(record, profile) {
+async function stopOwnedChrome(record, profile, operation) {
 	for (const signal of ["SIGTERM", "SIGKILL"]) {
-		const state = await chromeProcessStateAsync(record, profile);
+		operation?.signal.throwIfAborted();
+		const state = await chromeProcessStateAsync(record, profile, operation);
 		if (state === "gone") return true;
 		if (state === "unknown") return false;
 		try {
-			await signalProcessTreeAsync(record.pid, signal, { group: true });
-		} catch {}
+			await signalProcessTreeAsync(record.pid, signal, {
+				group: true,
+				operation
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
+		}
 		const deadline = Date.now() + CHROME_KILL_WAIT_MS;
-		while (await chromeProcessStateAsync(record, profile) !== "gone" && Date.now() < deadline) await sleepAsync(50);
+		while (await chromeProcessStateAsync(record, profile, operation) !== "gone" && Date.now() < deadline) await cancellableSleep(50, {
+			signal: operation?.signal,
+			what: "Chrome shutdown"
+		});
 	}
-	return await chromeProcessStateAsync(record, profile) === "gone";
+	return await chromeProcessStateAsync(record, profile, operation) === "gone";
 }
-const sleepAsync = (ms) => new Promise((done) => setTimeout(done, ms));
 /**
 * Closes the workspace's Stim-owned Chrome and its supervisor, after verifying both process identities. With
 * `deleteProfile`, it also deletes the profile directory, only when the created-devices ledger lists it.
@@ -932,9 +1050,13 @@ async function teardownOwnedBrowser(root, options = {}) {
 	try {
 		return await withWorkspaceProcessLock(workspaceDir(root), "web", () => teardownBrowserHeld(root, options), {
 			external: true,
-			ownerPurpose: "browser teardown"
+			ownerPurpose: "browser teardown",
+			signal: options.operation?.signal,
+			declareSpawnsFor: options.operation
 		});
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		options.operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
@@ -942,8 +1064,10 @@ async function teardownOwnedBrowser(root, options = {}) {
 	}
 }
 /** {@link teardownOwnedBrowser} for a caller that already holds the {@link BROWSER_LOCK} lock. */
-async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
+async function teardownBrowserHeld(root, { deleteProfile = false, operation } = {}) {
+	const signal = operation?.signal;
 	try {
+		signal?.throwIfAborted();
 		const record = readWebRecord(root);
 		const profile = record?.profile ?? webProfileDir(root);
 		if (record) {
@@ -958,12 +1082,12 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 				try {
 					process.kill(record.pid, "SIGTERM");
 				} catch {}
-				if (!await (0, process_identity_exports.waitForProcessExit)(record, BROWSER_EXIT_WAIT_MS)) return {
+				if (!await (0, process_identity_exports.waitForProcessExit)(record, BROWSER_EXIT_WAIT_MS, signal)) return {
 					status: "failed",
 					reason: `browser supervisor pid ${record.pid} did not exit`
 				};
 			}
-			if (record.chromeProcess && !await stopOwnedChrome(record.chromeProcess, profile)) return {
+			if (record.chromeProcess && !await stopOwnedChrome(record.chromeProcess, profile, operation)) return {
 				status: "failed",
 				reason: `Chrome pid ${record.chromeProcess.pid} did not exit`
 			};
@@ -983,8 +1107,8 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 				kind: "not-verified",
 				reason: claims.status === "held" ? `the browser supervisor claim is still held${claims.holder ? ` by pid ${claims.holder.owner.pid}` : ""}` : `the browser supervisor claim could not be cleared (${claims.reason}); remove it with ${(0, ownership_claim_exports.claimRemoveCommand)(webClaimRoot(root))}`
 			};
-			await withWorkspaceStateLockAsync(root, () => clearWebRecord(root, record));
-			await releaseBrowserPort(root, record.cdpPort);
+			await withWorkspaceStateLockAsync(root, () => clearWebRecord(root, record), signal);
+			await releaseBrowserPort(root, record.cdpPort, signal);
 		} else {
 			const holder = liveProfileHolder(profile);
 			if (holder !== null) return {
@@ -993,8 +1117,9 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 				reason: `pid ${holder} holds ${profile} but no browser supervisor is recorded; it was left running`
 			};
 			const port = getProject(root)?.ports?.[CDP_PORT_LABEL];
-			if (typeof port === "number") await releaseBrowserPort(root, port);
+			if (typeof port === "number") await releaseBrowserPort(root, port, signal);
 		}
+		signal?.throwIfAborted();
 		if (existsSync(profile)) removeSingletonFiles(profile);
 		if (deleteProfile && existsSync(profile)) {
 			if (!readCreatedDevices$1().web.has(profile)) return {
@@ -1002,10 +1127,11 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 				kind: "not-owned",
 				reason: `${profile} is not in Stim's ledger; it was kept`
 			};
-			rmSync(profile, {
+			await rm(profile, {
 				recursive: true,
 				force: true
 			});
+			signal?.throwIfAborted();
 			forgetCreatedDevice("web", profile);
 		}
 		return record ? {
@@ -1013,6 +1139,8 @@ async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
 			label: `Chrome (${profile})`
 		} : { status: "missing" };
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		signal?.throwIfAborted();
 		return {
 			status: "failed",
 			reason: String(error?.message || error)
@@ -1055,6 +1183,21 @@ function candidatePids(dirs) {
 function bundleInstancePids(root) {
 	return candidatePids(bundleDirs(root));
 }
+async function bundleInstancePidsAsync(root, signal, operation) {
+	signal?.throwIfAborted();
+	const dirs = bundleDirs(root);
+	if (!dirs.length) return [];
+	return bundleCandidates(await runOperationFile(operation, getExecutor(), "ps", [
+		"-axww",
+		"-o",
+		"pid=,comm="
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL",
+		signal,
+		cwd: operation?.cwd
+	}), dirs).filter((pid) => pid !== process.pid);
+}
 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" });
 }
@@ -1078,24 +1221,27 @@ function failedBundleListing(record, error) {
 	return open;
 }
 /** Verifies owned bundle instances without blocking on process and executable probes. */
-async function runningBundleInstancesAsync(root) {
+async function runningBundleInstancesAsync(root, operation) {
+	operation?.signal.throwIfAborted();
 	const dirs = bundleDirs(root);
 	if (!dirs.length) return [];
-	const listing = await getExecutor().runFileAsync("ps", [
+	const listing = await runOperationFile(operation, getExecutor(), "ps", [
 		"-axww",
 		"-o",
 		"pid=,comm="
 	], {
+		cwd: operation?.cwd,
 		timeoutMs: 1e4,
 		killSignal: "SIGKILL"
 	});
 	const instances = [];
 	for (const pid of bundleCandidates(listing, dirs).filter((candidate) => candidate !== process.pid)) {
+		operation?.signal.throwIfAborted();
 		const record = bundleRecord(pid);
 		if (!record) continue;
 		let open;
 		try {
-			open = await getExecutor().runFileAsync("lsof", [
+			open = await runOperationFile(operation, getExecutor(), "lsof", [
 				"-a",
 				"-p",
 				String(pid),
@@ -1103,10 +1249,13 @@ async function runningBundleInstancesAsync(root) {
 				"txt",
 				"-Fn"
 			], {
+				cwd: operation?.cwd,
 				timeoutMs: 1e4,
 				killSignal: "SIGKILL"
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			const partial = failedBundleListing(record, error);
 			if (partial === null) continue;
 			open = partial;
@@ -1230,7 +1379,7 @@ async function defaultProbeReachable(url, signal) {
 	const status = await probePublicHttp(url, signal);
 	return status !== null && status > 0;
 }
-function waitForUrl(child, parseLine, timeoutMs) {
+function waitForUrl(child, parseLine, timeoutMs, signal) {
 	return new Promise((resolve) => {
 		let settled = false;
 		let lastLine = null;
@@ -1247,12 +1396,14 @@ function waitForUrl(child, parseLine, timeoutMs) {
 			child.stderr?.removeListener("data", onErr);
 			child.removeListener("error", onError);
 			child.removeListener("exit", onExit);
+			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				url,
 				exited,
 				lastLine
 			});
 		};
+		const onAbort = () => finish(null);
 		const onLine = (line) => {
 			if (settled) return;
 			if (line.trim()) lastLine = line.trim();
@@ -1276,9 +1427,11 @@ function waitForUrl(child, parseLine, timeoutMs) {
 		child.on("error", onError);
 		child.on("exit", onExit);
 		timer = setTimeout(() => finish(null), timeoutMs);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) onAbort();
 	});
 }
-function waitForFileUrl(child, logFile, parseLine, timeoutMs) {
+function waitForFileUrl(child, logFile, parseLine, timeoutMs, signal) {
 	return new Promise((resolve) => {
 		let settled = false;
 		let watcher = null;
@@ -1290,11 +1443,13 @@ function waitForFileUrl(child, logFile, parseLine, timeoutMs) {
 			clearTimeout(timer);
 			child.removeListener("error", onError);
 			child.removeListener("exit", onExit);
+			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				url,
 				exited
 			});
 		};
+		const onAbort = () => finish(null);
 		const probe = () => {
 			try {
 				for (const line of readFileSync(logFile, "utf-8").split(/\r?\n/)) {
@@ -1319,7 +1474,9 @@ function waitForFileUrl(child, logFile, parseLine, timeoutMs) {
 		} catch {}
 		const interval = setInterval(probe, Math.min(1e3, timeoutMs));
 		const timer = setTimeout(() => finish(null), timeoutMs);
-		probe();
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) onAbort();
+		else probe();
 	});
 }
 function createTunnelLogFile(provider) {
@@ -1342,17 +1499,25 @@ function removeRecordedTunnelLogFile(path) {
 	if (!resolved.startsWith(`${dir}${sep}`) || resolve(join(dir, basename(resolved))) !== resolved) return;
 	removeTunnelLogFile(resolved);
 }
-async function waitUntilReachable({ url, now, sleep, probe, timeoutMs }) {
+async function waitUntilReachable({ url, now, sleep, probe, timeoutMs, signal }) {
 	const deadline = now() + timeoutMs;
 	for (;;) {
-		if (await probe(url, new AbortController().signal).catch(() => false)) return true;
+		throwIfCancelled(signal, "Metro tunnel startup");
+		const controller = new AbortController();
+		const ok = await probe(url, signal ? AbortSignal.any([signal, controller.signal]) : controller.signal).catch(() => false);
+		throwIfCancelled(signal, "Metro tunnel startup");
+		if (ok) return true;
 		if (now() >= deadline) return false;
-		await sleep(REACHABLE_POLL_MS);
+		if (sleep === defaultSleep) await cancellableSleep(REACHABLE_POLL_MS, {
+			signal,
+			what: "Metro tunnel startup"
+		});
+		else await sleep(REACHABLE_POLL_MS);
 	}
 }
 const CLEANUP_TIMEOUT_MS = 1e3;
-const CLEANUP_POLL_MS = 25;
-async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_TIMEOUT_MS, reachableTimeoutMs = REACHABLE_TIMEOUT_MS, probeReachable = defaultProbeReachable, now = Date.now, sleep = defaultSleep, ngrokUrl = null, requireReachable = true, cleanupTimeoutMs = CLEANUP_TIMEOUT_MS, isChildAlive = pidExists, readProcessToken = process_identity_exports.captureProcessToken, logFile = null }) {
+async function startTunnel({ claims = [], signal, provider, port, spawnFn = null, urlTimeoutMs = URL_TIMEOUT_MS, reachableTimeoutMs = REACHABLE_TIMEOUT_MS, probeReachable = defaultProbeReachable, now = Date.now, sleep = defaultSleep, ngrokUrl = null, requireReachable = true, cleanupTimeoutMs = CLEANUP_TIMEOUT_MS, isChildAlive = pidExists, readProcessToken = process_identity_exports.captureProcessToken, logFile = null }) {
+	throwIfCancelled(signal, "Metro tunnel startup");
 	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
 	const outputFile = provider === "tailscale" ? null : logFile || (spawnFn ? null : createTunnelLogFile(provider));
 	let child;
@@ -1360,6 +1525,7 @@ async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_
 		const binary = provider === "tailscale" ? resolveTailscaleBinary((bin) => getExecutor().findExecutable(bin)) : provider;
 		if (!binary) throw new Error("Install Tailscale and sign in to your tailnet.");
 		const { bin, args } = tunnelArgv(provider, port, ngrokUrl, outputFile, binary);
+		for (const claim of claims) (0, ownership_claim_exports.markClaimChildPending)(claim);
 		child = spawn(bin, args, {
 			stdio: outputFile ? [
 				"ignore",
@@ -1373,6 +1539,7 @@ async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_
 			detached: true
 		});
 	} catch (err) {
+		for (const claim of claims) (0, ownership_claim_exports.clearClaimChild)(claim);
 		removeTunnelLogFile(outputFile);
 		return {
 			failed: true,
@@ -1380,33 +1547,40 @@ async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_
 		};
 	}
 	let childExited = false;
+	let childIdentity = null;
 	child.once("exit", () => {
 		childExited = true;
 	});
 	const cleanup = async (alreadyExited = childExited) => {
-		const stopped = await terminateChild(child, {
+		if (claims.length > 0 && childIdentity && process.platform !== "win32" && (0, process_identity_exports.inspectProcessIdentity)(childIdentity) === "same") try {
+			signalProcessTree(childIdentity.pid, "SIGTERM", { group: true });
+		} catch {}
+		const drained = await terminateChild(child, {
 			alreadyExited,
 			timeoutMs: cleanupTimeoutMs,
-			now,
-			sleep,
-			isAlive: isChildAlive
-		});
-		if (stopped) removeTunnelLogFile(outputFile);
-		return stopped ? { status: "stopped" } : {
+			isAlive: isChildAlive,
+			waitForGroup: claims.length > 0 && process.platform !== "win32"
+		}) && (claims.length === 0 || process.platform === "win32" || !child.pid || !(0, ownership_claim_exports.processGroupAlive)(child.pid));
+		if (drained) {
+			for (const claim of claims) (0, ownership_claim_exports.clearClaimChild)(claim);
+			removeTunnelLogFile(outputFile);
+		}
+		return drained ? { status: "stopped" } : {
 			status: "failed",
 			reason: `Sent SIGKILL but could not confirm that pid ${child.pid ?? "unknown"} exited.`
 		};
 	};
 	const failAfterCleanup = async (reason, alreadyExited = childExited) => {
 		const stopped = await cleanup(alreadyExited);
-		return stopped.status === "stopped" ? {
-			failed: true,
-			reason
-		} : {
+		if (stopped.status === "failed") return {
 			failed: true,
 			reason: `${reason} ${stopped.reason}`,
 			cleanupFailed: true
 		};
+		return {
+			failed: true,
+			reason: signal?.aborted ? "Metro tunnel startup was cancelled." : reason
+		};
 	};
 	const pid = child.pid;
 	if (!pid) return failAfterCleanup(`${provider} started but reported no pid.`);
@@ -1419,18 +1593,35 @@ async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_
 	};
 	const initialProcessToken = captureChildIdentity();
 	if (!initialProcessToken) return failAfterCleanup(`${provider} started but its process identity token could not be read.`);
-	const { url, exited, lastLine } = outputFile ? await waitForFileUrl(child, outputFile, parserFor(provider), urlTimeoutMs) : await waitForUrl(child, parserFor(provider), urlTimeoutMs);
+	childIdentity = {
+		pid,
+		processToken: initialProcessToken
+	};
+	if (claims.length > 0) try {
+		for (const claim of claims) (0, ownership_claim_exports.setClaimChild)(claim, childIdentity);
+	} catch (error) {
+		return failAfterCleanup(`Could not record ${provider} process ownership: ${describe(error)}`);
+	}
+	const { url, exited, lastLine } = outputFile ? await waitForFileUrl(child, outputFile, parserFor(provider), urlTimeoutMs, signal) : await waitForUrl(child, parserFor(provider), urlTimeoutMs, signal);
 	if (!url) return failAfterCleanup(exited ? provider === "tailscale" && lastLine ? `${provider} exited before printing a tunnel URL: ${lastLine}` : `${provider} exited before printing a tunnel URL.` : `${provider} did not print a tunnel URL within ${urlTimeoutMs}ms.`, exited || childExited);
 	if (!outputFile) resumeChildPipes(child);
 	if (requireReachable) {
-		if (!await waitUntilReachable({
-			url,
-			now,
-			sleep,
-			probe: probeReachable,
-			timeoutMs: reachableTimeoutMs
-		})) return failAfterCleanup(`${url} did not become reachable within ${reachableTimeoutMs}ms; ${provider} may still be registering, or the network path is blocked.`);
+		let reachable;
+		try {
+			reachable = await waitUntilReachable({
+				url,
+				now,
+				sleep,
+				probe: probeReachable,
+				timeoutMs: reachableTimeoutMs,
+				signal
+			});
+		} catch (cause) {
+			return failAfterCleanup(`Could not establish ${provider} tunnel reachability: ${describe(cause)}`);
+		}
+		if (!reachable) return failAfterCleanup(`${url} did not become reachable within ${reachableTimeoutMs}ms; ${provider} may still be registering, or the network path is blocked.`);
 	}
+	if (signal?.aborted) return failAfterCleanup("Metro tunnel startup was cancelled.");
 	const finalProcessToken = captureChildIdentity();
 	if (!finalProcessToken || finalProcessToken !== initialProcessToken) return failAfterCleanup(`${provider} process identity changed before its tunnel could be recorded.`);
 	if (!outputFile) unrefChildPipes(child);
@@ -1444,10 +1635,16 @@ async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_
 		cleanup: () => cleanup()
 	};
 }
-async function startTunnelSequence({ providers, port, ngrokUrl = null, requireReachable = true, start = startTunnel }) {
+async function startTunnelSequence({ claims = [], signal, providers, port, ngrokUrl = null, requireReachable = true, start = startTunnel }) {
 	const failures = [];
 	for (const provider of providers) {
+		if (signal?.aborted) return {
+			failed: true,
+			reason: "Metro tunnel startup was cancelled."
+		};
 		const result = await start({
+			claims,
+			signal,
 			provider,
 			port,
 			ngrokUrl: provider === "ngrok" ? ngrokUrl : null,
@@ -1460,7 +1657,8 @@ async function startTunnelSequence({ providers, port, ngrokUrl = null, requireRe
 		failures.push(`${provider}: ${result.reason}`);
 		if (result.cleanupFailed) return {
 			failed: true,
-			reason: failures.join(" ")
+			reason: failures.join(" "),
+			cleanupFailed: true
 		};
 	}
 	return {
@@ -1480,50 +1678,53 @@ function resumeChildPipes(child) {
 	child.stdout?.resume?.();
 	child.stderr?.resume?.();
 }
-async function signalAndWaitForExit(child, signal, { timeoutMs, now, sleep, isAlive, platform }) {
-	let exited = false;
-	const onExit = () => {
-		exited = true;
-	};
-	child.once("exit", onExit);
-	try {
-		if (platform === "win32" && child.pid) signalProcessTree(child.pid, signal, { platform });
-		child.kill(signal);
-	} catch (err) {
-		child.removeListener("exit", onExit);
-		return isEsrch(err);
-	}
-	const hasExited = () => exited;
-	const deadline = now() + timeoutMs;
-	while (!hasExited() && now() < deadline) await sleep(CLEANUP_POLL_MS);
-	if (!hasExited() && child.pid && !isAlive(child.pid)) exited = true;
-	child.removeListener("exit", onExit);
-	return hasExited();
-}
-async function terminateChild(child, { alreadyExited, timeoutMs, now, sleep, isAlive, platform = process.platform }) {
-	if (alreadyExited) {
-		closeChildPipes(child);
-		return true;
-	}
-	if (await signalAndWaitForExit(child, "SIGTERM", {
-		timeoutMs,
-		now,
-		sleep,
-		isAlive,
-		platform
-	})) {
-		closeChildPipes(child);
-		return true;
-	}
-	const killed = await signalAndWaitForExit(child, "SIGKILL", {
+function signalAndWaitForExit(child, signal, { timeoutMs, isAlive, platform }) {
+	return new Promise((resolve) => {
+		let settled = false;
+		let timer;
+		const onExit = () => finish(true);
+		const onError = (error) => finish(isEsrch(error));
+		const finish = (exited) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			child.removeListener("exit", onExit);
+			child.removeListener("error", onError);
+			resolve(exited);
+		};
+		child.once("exit", onExit);
+		child.once("error", onError);
+		try {
+			if (platform === "win32" && child.pid) signalProcessTree(child.pid, signal, { platform });
+			child.kill(signal);
+		} catch (error) {
+			finish(isEsrch(error));
+		}
+		if (!settled) timer = setTimeout(() => finish(Boolean(child.pid && !isAlive(child.pid))), timeoutMs);
+	});
+}
+async function terminateChild(child, { alreadyExited, timeoutMs, isAlive, platform = process.platform, waitForGroup = false }) {
+	let stopped = alreadyExited;
+	let deadline = Date.now() + timeoutMs;
+	if (!stopped) stopped = await signalAndWaitForExit(child, "SIGTERM", {
 		timeoutMs,
-		now,
-		sleep,
 		isAlive,
 		platform
 	});
+	if (!stopped) {
+		deadline = Date.now() + timeoutMs;
+		stopped = await signalAndWaitForExit(child, "SIGKILL", {
+			timeoutMs,
+			isAlive,
+			platform
+		});
+	}
+	if (stopped && waitForGroup && child.pid) {
+		while ((0, ownership_claim_exports.processGroupAlive)(child.pid) && Date.now() < deadline) await cancellableSleep(25);
+		stopped = !(0, ownership_claim_exports.processGroupAlive)(child.pid);
+	}
 	closeChildPipes(child);
-	return killed;
+	return stopped;
 }
 function describe(err) {
 	return err?.message || String(err);
@@ -1533,7 +1734,14 @@ const STOP_POLL_MS = 100;
 function isEsrch(err) {
 	return err?.code === "ESRCH";
 }
-async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity, platform = process.platform, kill = (pid) => signalProcessTreeAsync(pid, "SIGTERM", { platform }), now = Date.now, sleep = defaultSleep, timeoutMs = STOP_TIMEOUT_MS } = {}) {
+async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity, platform = process.platform, operation, kill = (pid) => signalProcessTreeAsync(pid, "SIGTERM", {
+	platform,
+	operation
+}), now = Date.now, sleep = operation ? (ms) => cancellableSleep(ms, {
+	signal: operation.signal,
+	what: "tunnel stop"
+}) : defaultSleep, timeoutMs = STOP_TIMEOUT_MS } = {}) {
+	operation?.signal.throwIfAborted();
 	const missing = () => {
 		removeRecordedTunnelLogFile(record?.logFile);
 		return { status: "missing" };
@@ -1553,6 +1761,8 @@ async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = proce
 	try {
 		await kill(pid);
 	} catch (err) {
+		if (err instanceof WorkspaceProcessCleanupError) throw err;
+		operation?.signal.throwIfAborted();
 		return isEsrch(err) ? missing() : {
 			status: "failed",
 			reason: describe(err)
@@ -1564,7 +1774,11 @@ async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = proce
 		const current = inspectIdentity(record);
 		return current === "gone" || current === "different";
 	};
-	while (now() < deadline && !exited()) await sleep(STOP_POLL_MS);
+	while (now() < deadline && !exited()) {
+		operation?.signal.throwIfAborted();
+		await sleep(STOP_POLL_MS);
+	}
+	operation?.signal.throwIfAborted();
 	if (!exited()) return {
 		status: "failed",
 		reason: `pid ${pid} did not exit within ${timeoutMs}ms.`
@@ -1638,7 +1852,7 @@ function numberOrNull(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 } = {}) {
+function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted = true, nativeRun = true } = {}, bundleInstances = bundleInstancePids) {
 	const reasons = [];
 	if (supervisor) {
 		const project = getProject(root);
@@ -1654,7 +1868,7 @@ function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted =
 		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);
+			const pids = bundleInstances(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}`);
@@ -1683,20 +1897,44 @@ function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted =
 	if (managedLocks) reasons.push(...managedLockHolders(root));
 	return reasons;
 }
-function emptyWorkspaceDir(dir) {
-	if (lstatSync(dir).isSymbolicLink()) {
-		unlinkSync(dir);
-		return;
+async function workspaceInUseAsync(root, checks = {}, signal, operation) {
+	let instances;
+	try {
+		instances = checks.supervisor === false ? [] : await bundleInstancePidsAsync(root, signal, operation);
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		signal?.throwIfAborted();
+		instances = error instanceof Error ? error : new Error(String(error));
 	}
-	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join(dir, name), {
-		recursive: true,
-		force: true
+	signal?.throwIfAborted();
+	return workspaceInUse(root, checks, () => {
+		if (instances instanceof Error) throw instances;
+		return instances;
 	});
 }
-async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+async function emptyWorkspaceDir(dir, signal) {
+	signal?.throwIfAborted();
+	const stat = await lstat(dir);
+	signal?.throwIfAborted();
+	if (stat.isSymbolicLink()) {
+		await unlink(dir);
+		return;
+	}
+	for (const name of await readdir(dir)) {
+		signal?.throwIfAborted();
+		if (name !== `${NATIVE_RUN}.lock`) await rm(join(dir, name), {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function withIdleWorkspace(root, fn, { purpose, operation, signal = operation?.signal, ...checks }) {
 	try {
 		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
-			const reasons = workspaceInUse(root, {
+			const reasons = signal ? await workspaceInUseAsync(root, {
+				...checks,
+				nativeRun: false
+			}, signal, operation) : workspaceInUse(root, {
 				...checks,
 				nativeRun: false
 			});
@@ -1711,9 +1949,13 @@ async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
 		}, {
 			external: true,
 			waitMs: 0,
-			ownerPurpose: purpose
+			ownerPurpose: purpose,
+			signal,
+			declareSpawnsFor: operation
 		});
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		signal?.throwIfAborted();
 		if (workspaceProcessLockError(error)) return {
 			ran: false,
 			reasons: [NATIVE_RUN_HELD]
@@ -1744,11 +1986,17 @@ function readRecordedRoot(dir, name) {
 	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"
-		};
+		return unreadableRecordedRoot(error);
 	}
+	return recordedRoot(parsed, name);
+}
+function unreadableRecordedRoot(error) {
+	return {
+		projectRoot: null,
+		problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
+	};
+}
+function recordedRoot(parsed, name) {
 	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
 	if (typeof projectRoot !== "string" || !isAbsolute$1(projectRoot)) return {
 		projectRoot: null,
@@ -1786,6 +2034,42 @@ function listWorkspaceDirs() {
 	}
 	return entries;
 }
+async function listWorkspaceDirsAsync(signal) {
+	signal?.throwIfAborted();
+	const root = workspacesRoot();
+	let names;
+	try {
+		names = (await readdir(root)).toSorted();
+	} catch {
+		signal?.throwIfAborted();
+		return [];
+	}
+	const entries = [];
+	for (const name of names) {
+		signal?.throwIfAborted();
+		const dir = join$1(root, name);
+		try {
+			if (!(await stat(dir)).isDirectory()) continue;
+		} catch {
+			signal?.throwIfAborted();
+			continue;
+		}
+		signal?.throwIfAborted();
+		let recorded;
+		try {
+			recorded = recordedRoot(JSON.parse(await readFile(join$1(dir, "workspace.json"), "utf8")), name);
+		} catch (error) {
+			signal?.throwIfAborted();
+			recorded = unreadableRecordedRoot(error);
+		}
+		signal?.throwIfAborted();
+		entries.push({
+			dir,
+			...recorded
+		});
+	}
+	return entries;
+}
 function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse }) {
 	const orphaned = [];
 	const skipped = [];
@@ -1841,28 +2125,47 @@ function rootPresence(path) {
 		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)
-	});
-	if (!measure) return classified;
-	return (async () => {
-		const orphaned = [];
-		for (const entry of classified.orphaned) {
-			const bytes = await measuredDirectorySizeAsync(entry.dir, { timeoutMs: SIZE_TIMEOUT_MS });
-			orphaned.push({
-				...entry,
-				bytes
+async function collectOrphanedWorkspaces(registryKeys, mountedVolumes, { measure = true, operation } = {}) {
+	const classified = {
+		orphaned: [],
+		skipped: []
+	};
+	for (const entry of await listWorkspaceDirsAsync(operation?.signal)) {
+		operation?.signal.throwIfAborted();
+		const current = classifyWorkspaceDirs([entry], {
+			registryKeys,
+			exists: rootPresence,
+			isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
+			inUse: () => []
+		});
+		classified.skipped.push(...current.skipped);
+		for (const orphan of current.orphaned) {
+			const reasons = operation ? await workspaceInUseAsync(orphan.projectRoot, {}, operation.signal, operation) : workspaceInUse(orphan.projectRoot);
+			if (reasons.length) classified.skipped.push({
+				dir: orphan.dir,
+				reason: `its project root ${orphan.projectRoot} is gone, but ${reasons.join("; ")}`
 			});
+			else classified.orphaned.push(orphan);
 		}
-		return {
-			orphaned,
-			skipped: classified.skipped
-		};
-	})();
+	}
+	if (!measure) return classified;
+	const orphaned = [];
+	for (const entry of classified.orphaned) {
+		operation?.signal.throwIfAborted();
+		const bytes = await measuredDirectorySizeAsync(entry.dir, {
+			timeoutMs: SIZE_TIMEOUT_MS,
+			operation,
+			signal: operation?.signal
+		});
+		orphaned.push({
+			...entry,
+			bytes
+		});
+	}
+	return {
+		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 = [
@@ -1897,47 +2200,53 @@ function outputPaths(dir) {
 	} catch {}
 	return paths;
 }
-async function outputBytes(paths, timeoutMs) {
+async function outputBytes(paths, timeoutMs, signal, operation) {
 	let total = 0;
 	for (const path of paths) {
-		const size = await measuredDirectorySizeAsync(path, { timeoutMs });
+		const size = await measuredDirectorySizeAsync(path, {
+			timeoutMs,
+			signal,
+			operation
+		});
 		if (size === null) return null;
 		total += size;
 	}
 	return total;
 }
-function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS }) {
+function collectWorkspaceOutputs({ olderThan, now, exclude = [], measure = true, sizeTimeoutMs = SIZE_TIMEOUT_MS, signal, operation }) {
 	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);
+	const outputEntries = (entries) => entries.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);
 	const report = (sizes) => ({
 		root: workspacesRoot(),
-		workspaces: planWorkspaceOutputs(sizes.map((entry) => ({
-			...entry,
-			lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
-			inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
-		})), {
+		workspaces: planWorkspaceOutputs(sizes.map((entry) => Object.assign({}, entry, { lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot) })), {
 			olderThan,
 			now
 		})
 	});
-	if (!measure) return report(entries.map(({ paths: _paths, ...entry }) => ({
-		...entry,
-		bytes: null
+	if (!measure && !signal) return report(outputEntries(listWorkspaceDirs()).map(({ paths: _paths, ...entry }) => Object.assign({}, entry, {
+		bytes: null,
+		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
 	})));
 	return (async () => {
 		const sizes = [];
-		for (const { paths, ...entry } of entries) sizes.push({
-			...entry,
-			bytes: await outputBytes(paths, sizeTimeoutMs)
-		});
+		const entries = outputEntries(await listWorkspaceDirsAsync(signal));
+		for (const { paths, ...entry } of entries) {
+			signal?.throwIfAborted();
+			sizes.push({
+				...entry,
+				bytes: measure ? await outputBytes(paths, sizeTimeoutMs, signal, operation) : null,
+				inUse: entry.projectRoot === null ? [] : signal ? await workspaceInUseAsync(entry.projectRoot, {}, signal, operation) : workspaceInUse(entry.projectRoot)
+			});
+		}
 		return report(sizes);
 	})();
 }
-async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }, { log, record } = GC_OUTPUT) {
+async function clearWorkspaceOutputs(report, { olderThan, now = Date.now(), operation, signal = operation?.signal }, { log, record } = GC_OUTPUT) {
 	let failures = 0;
 	let cleared = 0;
 	const clearedRoots = [];
 	for (const entry of report.workspaces) {
+		signal?.throwIfAborted();
 		const root = entry.projectRoot;
 		if (!entry.willClear || root === null) {
 			if (entry.keptReason) {
@@ -1951,7 +2260,7 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }, {
 		}
 		let run;
 		try {
-			run = await withIdleWorkspace(root, () => {
+			run = await withIdleWorkspace(root, async () => {
 				const [again] = planWorkspaceOutputs([{
 					...entry,
 					problem: null,
@@ -1962,13 +2271,23 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }, {
 					now
 				});
 				if (again?.keptReason) return again.keptReason;
-				for (const path of outputPaths(entry.dir)) rmSync$1(path, {
-					recursive: true,
-					force: true
-				});
+				for (const path of outputPaths(entry.dir)) {
+					signal?.throwIfAborted();
+					await rm(path, {
+						recursive: true,
+						force: true
+					});
+				}
+				signal?.throwIfAborted();
 				return null;
-			}, { purpose: "gc" });
+			}, {
+				purpose: "gc",
+				signal,
+				operation
+			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			signal?.throwIfAborted();
 			failures++;
 			log(chalk.red(`Could not clear the build outputs of ${root}: ${error?.message || String(error)}`));
 			record("workspaceOutputs", "failed", root, {
@@ -2001,47 +2320,56 @@ 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) {
+async function deleteOrphanedWorkspaces(orphaned, output = GC_OUTPUT, operation) {
 	let failures = 0;
 	for (const entry of orphaned) {
+		operation?.signal.throwIfAborted();
 		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 });
+				const browser = await teardownOwnedBrowser(entry.projectRoot, {
+					deleteProfile: true,
+					...operation ? { operation } : {}
+				});
 				if (browser.status === "failed" || browser.status === "skipped") throw new Error(`its owned Chrome profile was kept: ${browser.reason}`);
-				emptyWorkspaceDir(entry.dir);
+				await emptyWorkspaceDir(entry.dir, operation?.signal);
 				return true;
-			}, { purpose: "gc" });
+			}, {
+				purpose: "gc",
+				operation
+			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			failures++;
-			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
-			recordGcResult("workspaceDirectory", "failed", entry.dir, {
+			output.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
+			output.record("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, {
+			output.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
+			output.record("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, {
+			output.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
+			output.record("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 });
+		output.log(chalk.green(`Removed the orphaned workspace directory ${entry.dir}${size}`));
+		output.record("workspaceDirectory", "done", entry.dir, { bytes: entry.bytes ?? null });
 	}
 	return failures;
 }
@@ -2049,4 +2377,4 @@ function sizeText(bytes) {
 	return bytes === null ? "size unknown" : formatBytes(bytes);
 }
 //#endregion
-export { teardownParkedIosSim as A, takeGcResults as B, eraseParkedAvd as C, teardownOwnedBrowser as D, teardownOwnedAvd as E, acquireBuildSlot as F, listBuildSlots as I, releaseBuildSlot as L, canonical$1 as M, measureDu as N, teardownOwnedIosSim as O, writeUsageCache as P, GC_OUTPUT as R, runningBundleInstancesAsync 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, probePublicHttp 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, recordGcResult as z };
+export { teardownParkedAvd as A, createGcResults as B, runningBundleInstancesAsync as C, teardownOwnedAvd as D, teardownBrowserHeld as E, writeUsageCache as F, acquireBuildSlot as I, listBuildSlots as L, probePublicHttp as M, canonical$1 as N, teardownOwnedBrowser as O, measureDu as P, releaseBuildSlot as R, withManagedTunnelRemovalLock as S, eraseParkedIosSim as T, takeGcResults as V, stopTunnel as _, collectWorkspaceOutputs as a, withManagedRemoteWorktreeRemovalLock as b, listWorkspaceDirs as c, emptyWorkspaceDir as d, withIdleWorkspace as f, startTunnelSequence as g, resolveSupervisorTarget as h, collectOrphanedWorkspaces as i, teardownParkedIosSim as j, teardownOwnedIosSim as k, rootPresence as l, workspaceInUseAsync 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, terminateChild as v, eraseParkedAvd as w, withManagedTunnelLock as x, withManagedRemoteWorktreeLock as y, GC_OUTPUT as z };