stim 1.20.2 → 1.22.0

package/dist/{stop-BNmBMi1F.mjs → stop-Mv6W9FAk.mjs}

@@ -1,21 +1,19 @@
-import { D as withConfigLock$1, E as upsertProject, H as parseDeviceSlotKey, K as validateDeviceSlot, U as parseDeviceSlotOption, V as deviceSlotPlatforms, W as projectDeviceSlots, j as ownership_claim_exports, k as process_identity_exports, o as clearSupervisor, p as getProject } from "./config-BYDxlMY3.mjs";
-import { r as debugLog } from "./exec-DqKo9GKJ.mjs";
-import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-BX1sJQ2E.mjs";
-import { a as updateWorkspaceState, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { A as clearWorkspaceSupervisor, D as clearManagedMetroTunnel, N as readRemoteSession, O as clearRemoteSession, j as readMetroTunnel, k as clearWorkspaceLaunches, n as findCommandWorkspace, w as MODE_COMMAND } from "./project-_phNIJfs.mjs";
-import { d as signalProcessTree, r as killMetroTree, s as pidExists, u as resolveProjectMetro } from "./metro-DnCEjCxs.mjs";
-import { D as stopTunnel, P as resolveSupervisorTarget, b as teardownOwnedIosSim, v as teardownOwnedAvd, y as teardownOwnedBrowser } from "./workspaces-C36s2jb9.mjs";
-import { _t as withdrawDevServerStopRequest, ht as requestDevServerStop, pt as logVanishedSupervisor } from "./budget-f7516Zk0.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-4WopRPg-.mjs";
-import { _ as nativeRunHolder, d as NATIVE_RUN_LOCK, f as NATIVE_RUN_WAIT_MS, g as describeNativeRunHolder, h as decideStopAction, m as clearNativeRunCancel, v as nativeRunWaitNotice, y as requestNativeRunCancel } from "./tailnet-Dh-qiYzG.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-OyOyVIS3.mjs";
-import { t as macosAppPresent } from "./state-CG_OFoaA.mjs";
-import { i as stopHostedAndroid } from "./hosted-android-C3MHGld1.mjs";
-import { i as endRecordedSession } from "./device-remote-xRT0Vmo9.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-DCtw_2IA.mjs";
-import { r as stopHostedIos } from "./hosted-ios-l-o3iM9J.mjs";
-import { n as stopMacosApp } from "./stop-DPEhunlw.mjs";
+import { b as debugLog, g as process_identity_exports, i as withWorkspaceProcessLock, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { E as upsertProject, G as projectDeviceSlots, H as deviceSlotPlatforms, O as withConfigLockAsync$1, U as parseDeviceSlotKey, W as parseDeviceSlotOption, o as clearSupervisor, p as getProject, q as validateDeviceSlot } from "./config-DlrsduwG.mjs";
+import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-gwpm28fu.mjs";
+import { c as withWorkspaceStateLock, d as writeWorkspaceState, l as withWorkspaceStateLockAsync, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-U08dEzhG.mjs";
+import { A as clearWorkspaceLaunches, M as readMetroTunnel, O as clearManagedMetroTunnel, P as readRemoteSession, T as MODE_COMMAND, j as clearWorkspaceSupervisor, k as clearRemoteSession, n as findCommandWorkspace } from "./project-wM_XFTvE.mjs";
+import { t as macosAppPresent } from "./state-08I3hw3_.mjs";
+import { a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, h as isMetroRunning, p as signalProcessTreeAsync, r as killMetroTreeAsync, u as processCwds } from "./metro-DiXtA3Ty.mjs";
+import { S as withdrawDevServerStopRequest, b as requestDevServerStop, qn as resolveEasCliBin, v as logVanishedSupervisor, zt as endRecordedSession } from "./budget-Cvwn54qV.mjs";
+import { a as decideStopAction, c as nativeRunWaitNotice, i as clearNativeRunCancel, l as requestNativeRunCancel, n as NATIVE_RUN_WAIT_MS, o as describeNativeRunHolder, s as nativeRunHolder, t as NATIVE_RUN_LOCK } from "./native-run-NwUuxbkg.mjs";
+import { D as teardownOwnedAvd, O as teardownOwnedBrowser, _ as stopTunnel, h as resolveSupervisorTarget, k as teardownOwnedIosSim } from "./workspaces-CpANmBlq.mjs";
+import { O as releaseWorkspaceLeasesAsync, y as fileLeaseIo } from "./activity-CMLmzp7o.mjs";
+import { i as stopHostedAndroid } from "./hosted-android-B-9f-jkd.mjs";
+import { r as stopHostedIos } from "./hosted-ios-CsCS21hn.mjs";
+import { n as stopMacosApp } from "./stop-Dky10AEJ.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-C5fo5Edb.mjs";
 import { hostedAndroidDeviceName, hostedAndroidRecords, hostedIosRecords, hostedNativeRecords, isJsonObject, parseHostedNativePlacement } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/stop.ts
@@ -103,20 +101,21 @@ function resolveCollectorTargets({ root, collectors, isAlive = pidExists, selfPi
 	}
 	return targets;
 }
-function defaultTeardownRemoteSession(root, sessionId) {
+async function defaultTeardownRemoteSession(root, sessionId, operation) {
 	return endRecordedSession({
 		root,
 		sessionId,
-		easBin: resolveEasCliBin(root)?.file ?? null
+		easBin: resolveEasCliBin(root)?.file ?? null,
+		operation
 	});
 }
-function endRemoteSession(root, sessionId, { teardownRemoteSession, report }) {
-	const result = teardownRemoteSession(root, sessionId);
+async function endRemoteSession(root, sessionId, { teardownRemoteSession, report }) {
+	const result = await teardownRemoteSession(root, sessionId);
 	if (result.status === "failed") report(chalk.red(phaseLine("device", result.reason ?? `could not stop remote session ${sessionId}`)));
 	else {
 		report(chalk.dim(phaseLine("device", `stopped remote session ${sessionId}`)));
 		if (result.reason) report(chalk.yellow(phaseLine("device", result.reason)));
-		else clearRemoteSession(root, sessionId);
+		else await withWorkspaceStateLockAsync(root, () => clearRemoteSession(root, sessionId));
 	}
 	return {
 		status: result.status,
@@ -148,19 +147,19 @@ async function runStop(options) {
 		collectors,
 		remoteDevice: null,
 		metroTunnel: null,
-		clearCollectors: (projectRoot, expected) => withWorkspaceStateLock(projectRoot, () => {
+		clearCollectors: (projectRoot, expected) => withWorkspaceStateLockAsync(projectRoot, () => {
 			clearCollectorState(projectRoot, expected);
 			return !Object.keys(readCollectorState(projectRoot)).some((key) => parseDeviceSlotKey(key)?.slot === slot);
 		}),
-		clearState: (projectRoot) => {
+		clearState: (projectRoot) => withWorkspaceStateLockAsync(projectRoot, () => {
 			clearWorkspaceLaunches(projectRoot, slot);
 			return true;
-		},
+		}),
 		clearRegistration: async () => true,
 		teardownBrowser: null,
 		stopMacos: false,
 		hostedSlot: slot,
-		releaseLeases: (projectRoot) => releaseWorkspaceLeases(projectRoot, { slot })
+		releaseLeases: (projectRoot) => releaseWorkspaceLeasesAsync(projectRoot, { slot })
 	});
 	result.outcomes.port = {
 		status: "kept",
@@ -262,7 +261,11 @@ async function stopWorkspaceMacos(root, failed, enabled) {
 		};
 	}
 }
-async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid, group) => signalProcessTree(pid, "SIGTERM", { group }), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, hostedSlot, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+async function stopWorkspace({ root, operation, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTreeAsync(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = (projectRoot, expected) => withWorkspaceStateLockAsync(projectRoot, () => clearCollectorState(projectRoot, expected)), isAlive = pidExists, killGroup = killMetroTreeAsync, signalServer = (pid, group) => signalProcessTreeAsync(pid, "SIGTERM", { group }), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = (port, projectRoot) => resolveProjectMetro(port, projectRoot, {
+	probe: (candidatePort) => isMetroRunning(candidatePort, operation?.signal),
+	pidsOf: listeningPidsAsync,
+	cwdOf: async (pid) => (await processCwds([pid])).get(pid) ?? null
+}), teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, hostedSlot, remoteDevice = void 0, teardownRemoteSession = (projectRoot, id) => defaultTeardownRemoteSession(projectRoot, id, operation), metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeasesAsync, freePort = defaultFreePort, clearRegistration = (projectRoot, expected) => defaultClearRegistration(projectRoot, expected, report), clearState = (projectRoot, expected) => withWorkspaceStateLockAsync(projectRoot, () => clearSupervisorState(projectRoot, expected)), report = (line) => console.error(line) }) {
 	const proj = project === void 0 ? getProject(root) : project;
 	const sup = state === void 0 ? readSupervisorState(root) : state;
 	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
@@ -352,7 +355,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 		stillHolding ??= "a collector could not be stopped";
 	} else if (outcomes.collectors.entries.length) {
 		debugLog.log("stop.phase.start", { phase: "clear-collectors" });
-		const cleared = clearCollectors(root, collectorRecords);
+		const cleared = await clearCollectors(root, collectorRecords);
 		debugLog.log("stop.phase.end", {
 			phase: "clear-collectors",
 			cleared
@@ -389,8 +392,17 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 		}
 	}
 	const releaseStoppedSupervisor = async () => {
-		const stateCleared = clearState(root, sup);
+		const stateCleared = await clearState(root, sup);
 		const registrationCleared = await clearRegistration(root, proj?.supervisor ?? null);
+		if (typeof registrationCleared === "object") {
+			ok = false;
+			outcomes.port = {
+				status: "kept",
+				port: reservedPort,
+				reason: registrationCleared.error
+			};
+			return;
+		}
 		if (stateCleared === false || registrationCleared === false) {
 			ok = false;
 			outcomes.port = {
@@ -410,7 +422,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 				report(chalk.dim(phaseLine("port", `keeping reservation ${reservedPort} -- ${keepPort}`)));
 				return;
 			}
-			if (freePort(root, reservedPort) === false) {
+			if (await freePort(root, reservedPort) === false) {
 				ok = false;
 				outcomes.port = {
 					status: "kept",
@@ -428,7 +440,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	};
 	if (stillHolding) report(chalk.dim(phaseLine("device", "left alone (something is still running)")));
 	else {
-		outcomes.device = shutDownDevices(proj, root, {
+		outcomes.device = await shutDownDevices(proj, root, {
 			teardownIos,
 			teardownAvd,
 			report
@@ -445,7 +457,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 		ok = false;
 	});
 	Object.assign(outcomes.device, hosted.devices);
-	updateWorkspaceState(root, (workspace) => {
+	await updateWorkspaceStateAsync(root, (workspace) => {
 		const slots = isJsonObject(workspace.deviceSlots) ? workspace.deviceSlots : {};
 		for (const name of ["default", ...Object.keys(slots)]) {
 			if (hostedSlot !== void 0 && name !== hostedSlot) continue;
@@ -463,7 +475,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	const remote = remoteDevice === void 0 ? readRemoteSession(root) : remoteDevice;
 	const sessionId = typeof remote?.sessionId === "string" ? remote.sessionId : null;
 	if (sessionId) {
-		outcomes.device.remote = endRemoteSession(root, sessionId, {
+		outcomes.device.remote = await endRemoteSession(root, sessionId, {
 			teardownRemoteSession,
 			report
 		});
@@ -483,7 +495,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			tunnelHolding = result.reason ?? `could not stop the ${tunnel.provider} tunnel`;
 			if (!stillHolding) stillHolding = tunnelHolding;
 			report(chalk.red(phaseLine("lan", tunnelHolding)));
-		} else if (!clearManagedMetroTunnel(root, tunnel)) {
+		} else if (!await withWorkspaceStateLockAsync(root, () => clearManagedMetroTunnel(root, tunnel))) {
 			tunnelHolding = "a replacement managed tunnel record appeared during cleanup and remains active";
 			stillHolding = stillHolding ?? tunnelHolding;
 			ok = false;
@@ -495,7 +507,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			report(chalk.red(phaseLine("lan", tunnelHolding)));
 		} else report(chalk.dim(phaseLine("lan", result.status === "missing" ? "tunnel already gone" : `stopped the ${tunnel.provider} tunnel`)));
 	} else if (tunnel?.kind === "expo") outcomes.metroTunnel = { status: "not-managed" };
-	outcomes.releasedLeases = releaseLeases(root);
+	outcomes.releasedLeases = await releaseLeases(root);
 	for (const lease of outcomes.releasedLeases) report(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
 	if (stillHolding) {
 		outcomes.port = {
@@ -510,7 +522,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			"stopped"
 		].includes(outcomes.supervisor.status) && !["refused", "failed"].includes(outcomes.metro.status);
 		if (tunnelHolding && serverIsDown) {
-			clearState(root, sup);
+			await clearState(root, sup);
 			await clearRegistration(root, proj?.supervisor ?? null);
 		}
 	} else await releaseStoppedSupervisor();
@@ -574,7 +586,7 @@ async function reapCollectors(root, collectors, { isAlive, signal, report, verif
 				});
 				continue;
 			}
-			signal(target.pid);
+			await signal(target.pid);
 			if (!await waiter(target.pid, collectors?.[target.platform]?.processToken)) {
 				entries.push({
 					platform: target.platform,
@@ -614,16 +626,20 @@ async function reapCollectors(root, collectors, { isAlive, signal, report, verif
 }
 async function stopSupervisor(target, { root, killGroup, waiter, report }) {
 	report(chalk.dim(phaseLine("stop", `sending SIGTERM to supervisor process group ${target.pid}`)));
-	requestDevServerStop(root, target.processToken, { by: "stim stop" });
+	try {
+		await withWorkspaceStateLockAsync(root, () => requestDevServerStop(root, target.processToken, { by: "stim stop" }));
+	} catch {}
 	let signalled = false;
 	try {
-		signalled = killGroup(target.pid, target.processToken);
+		signalled = await killGroup(target.pid, target.processToken);
 	} catch (e) {
 		signalled = false;
 		report(chalk.red(phaseLine("stop", `could not signal supervisor pid ${target.pid}: ${String(e?.message || e)}`)));
 	}
 	if (!signalled) {
-		withdrawDevServerStopRequest(root, target.processToken);
+		try {
+			await withWorkspaceStateLockAsync(root, () => withdrawDevServerStopRequest(root, target.processToken));
+		} catch {}
 		const reason = `could not signal supervisor pid ${target.pid}`;
 		report(chalk.red(phaseLine("stop", reason)));
 		return {
@@ -678,7 +694,7 @@ async function stopMetro(port, root, { server, supervisorGone, signalServer, ins
 		report(chalk.dim(phaseLine("metro", `sending SIGTERM to dev server pid ${serverPid} left by the supervisor`)));
 		let signalled = false;
 		try {
-			signalled = signalServer(serverPid, server?.mode === MODE_COMMAND);
+			signalled = await signalServer(serverPid, server?.mode === MODE_COMMAND);
 		} catch {}
 		if (signalled ? await waiter(serverPid, serverProcessToken) : ["gone", "different"].includes(inspectIdentity(serverRecord))) {
 			report(chalk.green(phaseLine("metro", `dev server pid ${serverPid}`)));
@@ -730,7 +746,7 @@ function occupiedSkipReason(reason, holders) {
 	const named = (holders || []).filter(Boolean);
 	return named.length ? `${reason} -- held by UI-test runner ${named.join(", ")}` : `${reason} -- ${OCCUPANCY_HINT}`;
 }
-function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report }) {
+async function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report }) {
 	const device = {
 		ios: null,
 		android: null
@@ -756,7 +772,7 @@ function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report
 					slot,
 					deviceId: iosUdid
 				});
-				const result = teardownIos(iosUdid, {
+				const result = await teardownIos(iosUdid, {
 					del: false,
 					label: iosName,
 					workspace
@@ -786,7 +802,7 @@ function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report
 					slot,
 					deviceId: android.avdName
 				});
-				const result = teardownAvd(android.avdName, {
+				const result = await teardownAvd(android.avdName, {
 					del: false,
 					workspace
 				});
@@ -895,7 +911,7 @@ function summarize(root, outcomes, ok) {
 	return `${ok ? "Stopped" : "Stopped with problems"}: ${what} (${root})`;
 }
 function defaultFreePort(root, port) {
-	return withConfigLock$1(() => {
+	return withConfigLockAsync$1(() => {
 		const current = getProject(root);
 		if (!current) return true;
 		if (current.supervisor || current.metroPort !== port) return false;
@@ -903,11 +919,13 @@ function defaultFreePort(root, port) {
 		return true;
 	});
 }
-async function defaultClearRegistration(root, expected) {
+async function defaultClearRegistration(root, expected, report) {
 	try {
-		return clearSupervisor(root, expected);
-	} catch {
-		return false;
+		return await withConfigLockAsync$1(() => clearSupervisor(root, expected));
+	} catch (error) {
+		const message = `Could not clear workspace registration: ${error instanceof Error ? error.message : String(error)}`;
+		report(chalk.red(phaseLine("stop", message)));
+		return { error: message };
 	}
 }
 const INTERRUPT_WAIT_MS = 6e4;
@@ -951,22 +969,30 @@ function workspaceDeviceSlots(root) {
 	if (typeof readRemoteSession(root)?.sessionId === "string" && !slots.includes("default")) slots.push("default");
 	return slots;
 }
-function readRemoteSessionEntry(root, report) {
+async function readRemoteSessionEntry(root, report, operation) {
 	const sessionId = readRemoteSession(root)?.sessionId;
 	if (typeof sessionId !== "string") return null;
 	report(chalk.dim(phaseLine("device", `ending remote session ${sessionId} without waiting on the build lock`)));
 	return endRemoteSession(root, sessionId, {
-		teardownRemoteSession: defaultTeardownRemoteSession,
+		teardownRemoteSession: (projectRoot, id) => defaultTeardownRemoteSession(projectRoot, id, operation),
 		report
 	});
 }
+function signalledHolder(holder) {
+	return nativeRunHolder(holder).takesSignals && holder.owner.pid !== process.pid;
+}
 /**
 * `stop` under the workspace's native-run lock. A billable remote session is ended as soon as the lock is
-* seen held; a live `ios` or `android` run that the stop leaves nothing to deploy to is interrupted with
-* SIGINT and given INTERRUPT_WAIT_MS to exit; a build for another slot that stays is left running while
+* seen held; a live `ios` or `android` run that the stop leaves nothing to deploy to is asked to cancel through
+* its workspace state, sent SIGINT when its holder is a CLI process, and given INTERRUPT_WAIT_MS to exit; a build
+* for another slot that stays is left running while
 * the slot stops without the lock; any other holder is waited on with a visible notice.
 */
-async function stopWorkspaceNow({ root, slot, report = (line) => console.error(line), now = Date.now, sleep, waitMs = NATIVE_RUN_WAIT_MS, interruptWaitMs = INTERRUPT_WAIT_MS, inspectIdentity = process_identity_exports.inspectProcessIdentity, interrupt = (pid) => process.kill(pid, "SIGINT"), endRemote = (projectRoot) => readRemoteSessionEntry(projectRoot, report), deviceSlots = workspaceDeviceSlots, recordedSlots = recordedDeviceSlots, stop = (options) => runStop(options) }) {
+async function stopWorkspaceNow({ root, operation, slot, report = (line) => console.error(line), now = Date.now, sleep, waitMs = NATIVE_RUN_WAIT_MS, interruptWaitMs = INTERRUPT_WAIT_MS, inspectIdentity = process_identity_exports.inspectProcessIdentity, interrupt = (pid) => process.kill(pid, "SIGINT"), endRemote = (projectRoot) => readRemoteSessionEntry(projectRoot, report, operation), deviceSlots = workspaceDeviceSlots, recordedSlots = recordedDeviceSlots, stop = (options) => runStop({
+	...options,
+	operation,
+	report
+}) }) {
 	if (slot === "web") return stop({
 		root,
 		slot
@@ -983,10 +1009,10 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 	};
 	let remote = null;
 	let remoteHandled = slot !== void 0;
-	const endRemoteNow = () => {
+	const endRemoteNow = async () => {
 		if (remoteHandled) return;
 		remoteHandled = true;
-		remote = endRemote(root);
+		remote = await endRemote(root);
 	};
 	const notice = nativeRunWaitNotice({
 		write: (line) => report(chalk.dim(phaseLine("lock", line))),
@@ -994,62 +1020,71 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 	});
 	let seen = null;
 	const interrupted = [];
-	const onHeld = (holder) => {
+	const onHeld = async (holder) => {
 		const at = now();
 		if (seen?.claimId === holder.claimId) {
 			if (seen.action === "interrupt" && at >= seen.deadline) {
 				if (inspectIdentity(holder.owner) !== "same") throw ownerGoneRefusal(holder, at);
+				const signalled = signalledHolder(holder);
 				throw new StopBlocked({
 					code: "STIM_STOP_BLOCKED",
-					message: `${describeNativeRunHolder(holder, at)} did not exit within ${Math.round(interruptWaitMs / 1e3)}s of SIGINT; it still holds this workspace's native-run claim at ${holder.path}.`,
-					remedy: `Wait for it to finish, or end it with \`kill ${holder.owner.pid}\`, then run \`stim stop\` again.`
+					message: `${describeNativeRunHolder(holder, at)} did not exit within ${Math.round(interruptWaitMs / 1e3)}s of ${signalled ? "SIGINT" : "the stop request"}; it still holds this workspace's native-run claim at ${holder.path}.`,
+					remedy: signalled ? `Wait for it to finish, or end it with \`kill ${holder.owner.pid}\`, then run \`stim stop\` again.` : `It runs inside process ${holder.owner.pid}, which embeds Stim (such as stim-server) and runs other work too. Wait for the run to finish, or cancel it from the client that started it, then run \`stim stop\` again.`
 				});
 			}
 			notice(holder);
 			return;
 		}
-		endRemoteNow();
-		const target = nativeRunHolder(holder);
-		if (unknownSlot) {
-			const refusal = target.slot === slot ? null : stillUnknown();
-			if (refusal) throw refusal;
-			unknownSlot = false;
-		}
-		const { action } = decideStopAction({
-			stopSlot: slot,
-			holder: target,
-			ownerIdentity: inspectIdentity(holder.owner),
-			deviceSlots: deviceSlots(root)
-		});
-		seen = {
-			claimId: holder.claimId,
-			action,
-			deadline: Number.POSITIVE_INFINITY
-		};
-		const who = describeNativeRunHolder(holder, at);
-		if (action === "proceed") {
-			notice(holder, `leaving ${who} running: slot ${target.slot} stays, so slot ${slot} stops without the build lock`);
-			throw new LeaveBuildRunning();
-		}
-		if (action === "refuse") throw ownerGoneRefusal(holder, at);
-		if (action === "interrupt") {
-			requestNativeRunCancel(root, holder.claimId);
-			interrupted.push(holder.claimId);
+		try {
+			const target = nativeRunHolder(holder);
+			if (unknownSlot) {
+				const refusal = target.slot === slot ? null : stillUnknown();
+				if (refusal) throw refusal;
+				unknownSlot = false;
+			}
+			const { action } = decideStopAction({
+				stopSlot: slot,
+				holder: target,
+				ownerIdentity: inspectIdentity(holder.owner),
+				deviceSlots: deviceSlots(root)
+			});
 			seen = {
 				claimId: holder.claimId,
 				action,
-				deadline: now() + interruptWaitMs
+				deadline: Number.POSITIVE_INFINITY
 			};
-			if (inspectIdentity(holder.owner) !== "same") return;
-			try {
-				interrupt(holder.owner.pid);
-			} catch (error) {
-				if (error?.code !== "ESRCH") throw error;
+			const who = describeNativeRunHolder(holder, at);
+			if (action === "proceed") {
+				notice(holder, `leaving ${who} running: slot ${target.slot} stays, so slot ${slot} stops without the build lock`);
+				throw new LeaveBuildRunning();
 			}
-			notice(holder, `interrupting ${who}: sent SIGINT, waiting up to ${Math.round(interruptWaitMs / 1e3)}s for it to exit`);
-			return;
+			if (action === "refuse") throw ownerGoneRefusal(holder, at);
+			if (action === "interrupt") {
+				await withWorkspaceStateLockAsync(root, () => requestNativeRunCancel(root, holder.claimId));
+				interrupted.push(holder.claimId);
+				seen = {
+					claimId: holder.claimId,
+					action,
+					deadline: now() + interruptWaitMs
+				};
+				if (inspectIdentity(holder.owner) !== "same") return;
+				const wait = `waiting up to ${Math.round(interruptWaitMs / 1e3)}s for it to exit`;
+				if (!signalledHolder(holder)) {
+					notice(holder, `interrupting ${who}: asked it to stop, ${wait}`);
+					return;
+				}
+				try {
+					interrupt(holder.owner.pid);
+				} catch (error) {
+					if (error?.code !== "ESRCH") throw error;
+				}
+				notice(holder, `interrupting ${who}: sent SIGINT, ${wait}`);
+				return;
+			}
+			notice(holder);
+		} finally {
+			await endRemoteNow();
 		}
-		notice(holder);
 	};
 	const withRemote = (result) => {
 		if (!remote || result.outcomes.device.remote) return result;
@@ -1067,9 +1102,11 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 			});
 		}, {
 			external: true,
+			signal: operation?.signal,
 			waitMs,
 			now,
 			...sleep ? { sleep } : {},
+			declareSpawnsFor: operation,
 			details: {
 				command: "stop",
 				...slot === void 0 ? {} : { slot }
@@ -1085,10 +1122,12 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 			refusal: error.refusal,
 			remote
 		};
-		if ((0, ownership_claim_exports.isClaimRefusal)(error)) endRemoteNow();
+		if ((0, ownership_claim_exports.isClaimRefusal)(error)) await endRemoteNow();
 		throw error;
 	} finally {
-		for (const claimId of interrupted) clearNativeRunCancel(root, claimId);
+		for (const claimId of interrupted) try {
+			await withWorkspaceStateLockAsync(root, () => clearNativeRunCancel(root, claimId));
+		} catch {}
 	}
 }
 function stopCommand(program) {

package/dist/supervisor-run.d.mts

@@ -1,6 +1,10 @@
-import { a as clearWorkspaceSupervisor, i as clearExpoMetroTunnel, n as MODE_BARE, o as readPidFile, r as MODE_EXPO, s as writePidFile, t as SettingsObject } from "./settings-vk3mJGSm.mjs";
-import { t as NdjsonWriter } from "./ndjson-Du3j0AQ9.mjs";
-import { DevServerStopRecord, DeviceActivity, DeviceIdleShutdownRecord, IOS_SIMULATOR_APPS } from "@stim-cli/core/state";
+import { c as readPidFile, i as MODE_EXPO, l as writePidFile, n as SettingsObject, o as clearExpoMetroTunnel, r as MODE_BARE, s as clearWorkspaceSupervisor } from "./ios-CDvlmUs7.mjs";
+import { n as NdjsonWriter } from "./exec-DnYc4HGH.mjs";
+import { n as OwnedDeviceActivity } from "./idle-C4cZ757K.mjs";
+import { DevServerStopRecord, DeviceIdleShutdownRecord } from "@stim-cli/core/state";
+//#region src/watchman.d.ts
+type WatchmanCommand = (args: string[], timeoutMs: number) => Promise<unknown>;
+//#endregion
 //#region src/supervisor/types.d.ts
 interface ServerExitInfo {
   code?: number | null;
@@ -30,16 +34,6 @@ interface IdleProbe {
   blocker(): string | null;
 }
 //#endregion
-//#region src/commands/gc/idle.d.ts
-interface OwnedDeviceActivity {
-  kind: "ios" | "android";
-  id: string;
-  name: string;
-  project: string;
-  slot: string;
-  activity: DeviceActivity;
-}
-//#endregion
 //#region src/devices/idle-shutdown.d.ts
 interface DueDevice {
   device: OwnedDeviceActivity;
@@ -60,10 +54,7 @@ interface IdleShutdownEvent {
 declare function shutDownIdleDevices(root: string, idleMs: number, log: (event: IdleShutdownEvent) => void, now?: number, { only, reason }?: {
   only?: OwnedDeviceActivity;
   reason?: DeviceIdleShutdownRecord["reason"];
-}): number;
-//#endregion
-//#region src/watchman.d.ts
-type WatchmanCommand = (args: string[], timeoutMs: number) => Promise<unknown>;
+}): Promise<number>;
 //#endregion
 //#region src/supervisor/run.d.ts
 interface ParsedSupervisorArgs {