stim 1.20.2 → 1.22.0

package/dist/{status-watch-C23ILtf9.mjs → status-watch-Bg_u-pwR.mjs}

@@ -1,13 +1,17 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { d as androidToolPath } from "./android-Mz_Inn3w.mjs";
-import { b as parseSimctlList } from "./ios-RkW4pnQf.mjs";
-import { n as easMachineStateRoot } from "./eas-session-ledger-Cm0Gwq2F.mjs";
-import { readdirSync, watch } from "node:fs";
-import { join } from "node:path";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { c as pidExists } from "./metro-DiXtA3Ty.mjs";
+import { n as easMachineStateRoot } from "./eas-session-ledger-DlY_serQ.mjs";
+import { d as androidToolPath } from "./android-C7sVmyI9.mjs";
+import { b as parseSimctlList } from "./ios-hcBpnEGk.mjs";
+import { existsSync, readdirSync, statSync, watch } from "node:fs";
+import { basename, dirname, join } from "node:path";
 //#region src/status-watch.ts
 const WATCH_FALLBACK_MS = 3e4;
-const WATCH_LIGHT_INTERVAL_MS = 15e3;
-const WATCH_SIMCTL_INTERVAL_MS = 5e3;
+const WATCH_LIGHT_INTERVAL_MS = 1e3;
+const WATCH_TABLES_INTERVAL_MS = 5e3;
+const WATCH_MACHINE_INTERVAL_MS = 15e3;
+const WATCH_PROCESS_INTERVAL_MS = 2e3;
+const WATCH_SIMCTL_INTERVAL_MS = 3e4;
 const ADB_RESTART_MIN_MS = 1e3;
 const ADB_RESTART_MAX_MS = 6e4;
 const SIMCTL_TIMEOUT_MS = 1e4;
@@ -86,6 +90,16 @@ function statusChange(dir, name) {
 		default: return "full";
 	}
 }
+/**
+* Whether a change to `name`, relative to a repository's git common directory, can change a worktree's git summary:
+* its HEAD, index or a ref, in the main worktree or a linked one. Objects, logs and lock files cannot on their own.
+*/
+function gitChange(name) {
+	if (name === null) return true;
+	const path = name.replaceAll("\\", "/");
+	if (path.endsWith(".lock")) return false;
+	return /^(HEAD|index|packed-refs|FETCH_HEAD)$/.test(path) || path.startsWith("refs/") || /^worktrees\/[^/]+(\/(HEAD|index))?$/.test(path) || path === "worktrees";
+}
 /** A stable summary of every simulator's state, or null when the listing is unreadable. */
 function simulatorSignature(simctlJson) {
 	try {
@@ -94,12 +108,18 @@ function simulatorSignature(simctlJson) {
 		return null;
 	}
 }
+const SIMULATOR_DIR = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
 /**
 * Calls `onChange` when anything `stim status` reports may have changed:
-* `$STIM_HOME` files, adb device arrivals and departures, and simulator
-* state. simctl has no push API reachable from Node, so it is polled.
+* `$STIM_HOME` files, git HEADs, indexes and refs of the watched repositories,
+* exits of the watched processes, adb device arrivals and departures, and
+* simulator state. Process liveness is polled with a signal 0 that spawns
+* nothing. simctl has no push API reachable from Node, so a simulator change is
+* a write CoreSimulator makes in `deviceSet`: to `device_set.plist`, a device
+* directory, or a device's `device.plist`, which carries its state. A slow
+* simctl poll covers events FSEvents drops and a device set that cannot be watched.
 */
-function watchStatusSources({ home, onChange, platform = process.platform, simctlIntervalMs = WATCH_SIMCTL_INTERVAL_MS }) {
+function watchStatusSources({ home, deviceSet, onChange, platform = process.platform, simctlIntervalMs = WATCH_SIMCTL_INTERVAL_MS }) {
 	let stopped = false;
 	const watchers = /* @__PURE__ */ new Map();
 	const desiredDirs = () => {
@@ -111,6 +131,7 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			[join(home, "device-locks"), "leases"],
 			[easMachineStateRoot(), "eas"]
 		]);
+		if (platform === "darwin") return dirs;
 		let names = [];
 		try {
 			names = readdirSync(join(home, "workspaces"));
@@ -132,11 +153,26 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 		for (const [dir, kind] of desired) {
 			if (watchers.has(dir)) continue;
 			try {
-				const watcher = watch(dir, (_event, name) => {
-					const change = statusChange(kind, name === null ? null : String(name));
+				const recursive = platform === "darwin" && kind === "workspaces";
+				const watcher = watch(dir, { recursive }, (_event, name) => {
+					let source = kind;
+					let filename = name === null ? null : String(name);
+					if (recursive && filename !== null) {
+						const [, entry, child, ...nested] = filename.split("/");
+						if (entry !== void 0) {
+							if (entry === "logs" && child !== void 0 && nested.length === 0) {
+								source = "logs";
+								filename = child;
+							} else if (child === void 0) {
+								source = "workspace";
+								filename = entry;
+							} else return;
+						}
+					}
+					const change = statusChange(source, filename);
 					if (!change) return;
-					if (kind === "home" || kind === "workspaces" || kind === "workspace") {
-						listingStaleBefore = Date.now();
+					if (source === "home" || source === "workspaces" || source === "workspace") {
+						listingVersion++;
 						reconcile();
 					}
 					onChange(change);
@@ -149,16 +185,114 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			} catch {}
 		}
 	};
+	const repositories = /* @__PURE__ */ new Map();
+	const watchRepositories = (commonDirs) => {
+		if (stopped) return;
+		const wanted = new Set(commonDirs);
+		for (const [dir, watcher] of repositories) {
+			if (wanted.has(dir)) continue;
+			watcher.close();
+			repositories.delete(dir);
+		}
+		for (const dir of wanted) {
+			if (repositories.has(dir)) continue;
+			try {
+				const watcher = watch(dir, { recursive: true }, (_event, name) => {
+					if (gitChange(name === null ? null : String(name))) onChange("full");
+				});
+				watcher.on("error", () => {
+					watcher.close();
+					repositories.delete(dir);
+				});
+				repositories.set(dir, watcher);
+			} catch {}
+		}
+	};
+	let processes = [];
+	const processTimer = setInterval(() => {
+		if (processes.some((pid) => !pidExists(pid))) {
+			processes = [];
+			onChange("full");
+		}
+	}, WATCH_PROCESS_INTERVAL_MS);
+	processTimer.unref();
 	const adb = trackAdbDevices(() => onChange("full"));
 	let simctl = null;
 	let listing = null;
-	let listingStaleBefore = 0;
+	let listingVersion = 0;
 	let simTimer = null;
-	if (platform === "darwin") {
+	const deviceWatchers = /* @__PURE__ */ new Map();
+	if (platform === "darwin" && deviceSet) {
+		const changed = () => {
+			listingVersion++;
+			check();
+			onChange("full");
+		};
+		const watchDir = (dir, listener) => {
+			try {
+				const ino = statSync(dir, { bigint: true }).ino;
+				const current = deviceWatchers.get(dir);
+				if (current?.ino === ino) return;
+				current?.watcher.close();
+				deviceWatchers.delete(dir);
+				const watcher = watch(dir, (_event, name) => {
+					if (!stopped && deviceWatchers.get(dir)?.watcher === watcher) listener(name === null ? null : String(name));
+				});
+				watcher.on("error", () => {
+					if (deviceWatchers.get(dir)?.watcher !== watcher) return;
+					watcher.close();
+					deviceWatchers.delete(dir);
+				});
+				deviceWatchers.set(dir, {
+					watcher,
+					ino
+				});
+			} catch {}
+		};
+		const watchDeviceSet = () => {
+			if (stopped) return;
+			let names = null;
+			try {
+				names = readdirSync(deviceSet);
+			} catch {}
+			const wanted = /* @__PURE__ */ new Set();
+			if (names) {
+				wanted.add(deviceSet);
+				for (const name of names) {
+					if (!SIMULATOR_DIR.test(name)) continue;
+					const dir = join(deviceSet, name);
+					const plist = join(dir, "device.plist");
+					wanted.add(existsSync(plist) ? plist : dir);
+				}
+			} else {
+				let dir = dirname(deviceSet);
+				while (dirname(dir) !== dir && !isDirectory(dir)) dir = dirname(dir);
+				wanted.add(dir);
+			}
+			for (const [dir, { watcher }] of deviceWatchers) {
+				if (wanted.has(dir)) continue;
+				watcher.close();
+				deviceWatchers.delete(dir);
+			}
+			for (const dir of wanted) if (dir === deviceSet) watchDir(dir, () => {
+				watchDeviceSet();
+				changed();
+			});
+			else if (basename(dir) === "device.plist") watchDir(dir, changed);
+			else if (dirname(dir) === deviceSet) watchDir(dir, (name) => {
+				if (name === null || name === "device.plist") changed();
+			});
+			else watchDir(dir, () => {
+				watchDeviceSet();
+				if (deviceWatchers.has(deviceSet)) changed();
+			});
+		};
 		let last = null;
 		const check = () => {
+			watchDeviceSet();
 			if (simctl || stopped) return;
 			const startedAt = Date.now();
+			const version = listingVersion;
 			let out = "";
 			const child = getExecutor().spawn("xcrun", [
 				"simctl",
@@ -176,18 +310,23 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			});
 			simctl = child;
 			child.stdout?.on("data", (chunk) => out += chunk.toString());
-			child.on("error", () => {
-				simctl = null;
-			});
+			child.on("error", () => {});
 			child.on("close", () => {
 				simctl = null;
+				if (stopped) return;
+				if (version !== listingVersion) {
+					check();
+					return;
+				}
 				const signature = simulatorSignature(out);
-				if (signature === null || stopped) return;
+				if (signature === null) return;
+				const wasStale = listing?.version !== version;
 				listing = {
 					at: startedAt,
+					version,
 					json: out
 				};
-				if (last !== null && signature !== last) onChange("full");
+				if (last !== null && (signature !== last || wasStale)) onChange("full");
 				last = signature;
 			});
 		};
@@ -197,12 +336,21 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 	reconcile();
 	return {
 		reconcile,
-		simulatorListing: () => listing && listing.at > listingStaleBefore && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
+		watchRepositories,
+		watchProcesses(pids) {
+			processes = [...new Set(pids)];
+		},
+		simulatorListing: () => listing && listing.version === listingVersion && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
 		stop() {
 			stopped = true;
 			for (const watcher of watchers.values()) watcher.close();
 			watchers.clear();
+			for (const watcher of repositories.values()) watcher.close();
+			repositories.clear();
+			clearInterval(processTimer);
 			if (simTimer) clearInterval(simTimer);
+			for (const { watcher } of deviceWatchers.values()) watcher.close();
+			deviceWatchers.clear();
 			simctl?.kill("SIGKILL");
 			adb.stop();
 		}
@@ -249,6 +397,13 @@ function trackAdbDevices(onChange) {
 		child?.kill("SIGTERM");
 	} };
 }
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
 function ownerKey(owner) {
 	return JSON.stringify([
 		owner.kind,
@@ -265,7 +420,7 @@ function ownerSteady(before, after) {
 /**
 * The payload `status --watch --json` prints. A usage figure keeps its value from the `previous` printed payload until it moves by a step: an owner's `cpuPercent`
 * and `memoryMb`, an environment's `memoryMb` and `capacity.committedMb`. An owner's row is kept whole, `residentMb`
-* and `processes` included, until one of its two figures moves, so a Mac whose processes only jitter prints no new line.
+* and `processes` included, until one of its two figures moves, so a machine whose processes only jitter prints no new line.
 */
 function watchPayload(previous, next) {
 	const payload = { ...next };
@@ -292,5 +447,47 @@ function watchPayload(previous, next) {
 	if (capacity.overCapacity === next.capacity.overCapacity && capacity.liveCount === next.capacity.liveCount && capacity.totalMemoryMb === next.capacity.totalMemoryMb && Math.abs(next.capacity.committedMb - capacity.committedMb) < 16) payload.capacity = capacity;
 	return payload;
 }
+const holdPullRequest = (worktree) => worktree.pullRequest ? {
+	...worktree,
+	pullRequest: {
+		...worktree.pullRequest,
+		checkedAt: ""
+	}
+} : worktree;
+/**
+* The string `status --watch --json` compares to decide whether a line is new. It is the payload with the bookkeeping
+* timestamps masked: each `pullRequest.checkedAt`, `maintenance.lastChecks`, `maintenance.lastPass.startedAt` and
+* `durationMs`, and `maintenance.running.startedAt`. A change in only those fields prints no line; any printed line
+* carries the current values.
+*/
+function watchChangeKey(payload) {
+	const { maintenance } = payload;
+	return JSON.stringify({
+		...payload,
+		environments: payload.environments.map((env) => env.worktree ? {
+			...env,
+			worktree: holdPullRequest(env.worktree)
+		} : env),
+		unprovisionedWorktrees: payload.unprovisionedWorktrees.map(holdPullRequest),
+		maintenance: maintenance && {
+			...maintenance,
+			lastChecks: {
+				pressure: null,
+				size: null,
+				worktree: null,
+				sweep: null
+			},
+			lastPass: maintenance.lastPass && {
+				...maintenance.lastPass,
+				startedAt: 0,
+				durationMs: 0
+			},
+			running: maintenance.running && {
+				...maintenance.running,
+				startedAt: ""
+			}
+		}
+	});
+}
 //#endregion
-export { watchStatusSources as a, watchPayload as i, WATCH_LIGHT_INTERVAL_MS as n, createRefreshScheduler as r, WATCH_FALLBACK_MS as t };
+export { createRefreshScheduler as a, watchStatusSources as c, WATCH_TABLES_INTERVAL_MS as i, WATCH_LIGHT_INTERVAL_MS as n, watchChangeKey as o, WATCH_MACHINE_INTERVAL_MS as r, watchPayload as s, WATCH_FALLBACK_MS as t };

package/dist/status-worker.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/status-worker.mjs

@@ -0,0 +1,19 @@
+import { n as runStatusWatch } from "./status-WBDajew2.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/status-worker.ts
+const STOP_EXIT_MS = 500;
+const cwd = workerData?.cwd;
+const watch = runStatusWatch({
+	json: true,
+	...typeof cwd === "string" ? { cwd } : {},
+	emit: (line) => parentPort?.postMessage({ line }),
+	failed: (message) => parentPort?.postMessage({ failed: message })
+});
+parentPort?.on("message", (message) => {
+	if (message !== "stop") return;
+	watch.stop();
+	parentPort?.close();
+	setTimeout(() => process.exit(0), STOP_EXIT_MS);
+});
+//#endregion
+export {};

package/dist/stim-desktop-D5OGpYZM.mjs

@@ -0,0 +1,112 @@
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { C as saveConfig, c as ensureConfig } from "./config-DlrsduwG.mjs";
+import { randomUUID } from "node:crypto";
+import { workspaceId } from "@stim-cli/core";
+import { readHomeIdentity, withConfigLockAsync } from "@stim-cli/core/state";
+import { realpath } from "node:fs/promises";
+import { sharedWorkspaceURL } from "@stim-cli/core/workspace-link";
+//#region src/workspace/home-identity.ts
+function ensureHomeIdentity(signal) {
+	return withConfigLockAsync(() => {
+		signal?.throwIfAborted();
+		const config = ensureConfig();
+		const existing = readHomeIdentity(config);
+		if (existing) return existing;
+		const id = randomUUID();
+		config.homeId = id;
+		saveConfig(config);
+		return id;
+	});
+}
+//#endregion
+//#region src/devices/stim-desktop.ts
+const LAUNCH_SERVICES_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier('dev.stim.desktop'); url.isNil() ? '' : url.path.js`;
+const SCHEME_HANDLER_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL($.NSURL.URLWithString('stim-desktop://workspace')); url.isNil() ? '' : url.path.js`;
+const STIM_DESKTOP_INSTALLED = "Stim Desktop installed";
+/**
+* macOS `open` passes its environment to an app it launches, so Stim Desktop
+* started by a command run under a scoped `STIM_HOME` would serve that home.
+*/
+const STIM_DESKTOP_OPEN_OPTIONS = {
+	timeoutMs: 5e3,
+	killSignal: "SIGKILL",
+	omitEnv: ["STIM_HOME"]
+};
+/** Stim Desktop sets `STIM_DESKTOP_APP` to its bundle path for every command it runs; a non-empty value means Desktop is installed. */
+function stimDesktopInstalled(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return launchServicesFinds(LAUNCH_SERVICES_LOOKUP);
+}
+/** `stimDesktopInstalled` without blocking the event loop. */
+async function stimDesktopInstalledAsync(platform = process.platform, env = process.env, onSpawn) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	const found = await getExecutor().runFileAsync("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		LAUNCH_SERVICES_LOOKUP
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL",
+		onSpawn
+	}).catch(() => "");
+	return Boolean(found);
+}
+function launchServicesFinds(script) {
+	return Boolean(getExecutor().runFileQuiet("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		script
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}));
+}
+async function stimDesktopHandlesLinks(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return Boolean(await getExecutor().runFileAsync("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		SCHEME_HANDLER_LOOKUP
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}).catch(() => ""));
+}
+/**
+* The links that open this workspace for a human, or undefined when no app on this Mac handles
+* `stim-desktop://`. `target` names the device Stim Desktop focuses when the user opens the workspace.
+*/
+async function workspaceLinks(root, target, handlesLinks = stimDesktopHandlesLinks) {
+	if (!await handlesLinks()) return void 0;
+	return { desktop: await workspaceShareURL(root, target) };
+}
+/** A share URL for the canonical workspace in this Stim home, usable by its already-paired phone or Desktop. */
+async function workspaceShareURL(root, target, signal) {
+	const canonical = await realpath(root);
+	return sharedWorkspaceURL({
+		machine: await ensureHomeIdentity(signal),
+		workspace: workspaceId(canonical),
+		...target
+	});
+}
+function workspaceLinkLine(links) {
+	return `Open in Stim: ${links.desktop}`;
+}
+function settingDefault(setting, desktopInstalled = stimDesktopInstalled) {
+	if (setting.desktopDefault !== void 0 && desktopInstalled()) return {
+		value: setting.desktopDefault,
+		reason: STIM_DESKTOP_INSTALLED
+	};
+	return {
+		value: setting.default,
+		reason: null
+	};
+}
+//#endregion
+export { workspaceLinkLine as a, ensureHomeIdentity as c, stimDesktopInstalledAsync as i, settingDefault as n, workspaceLinks as o, stimDesktopInstalled as r, workspaceShareURL as s, STIM_DESKTOP_OPEN_OPTIONS as t };

package/dist/{stop-DR6VoDIk.mjs → stop-DTZ9uTw3.mjs}

@@ -1,3 +1,3 @@
-import { P as resolveSupervisorTarget } from "./workspaces-C36s2jb9.mjs";
-import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BNmBMi1F.mjs";
+import { h as resolveSupervisorTarget } from "./workspaces-CpANmBlq.mjs";
+import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-Mv6W9FAk.mjs";
 export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop, stopWorkspaceNow };

package/dist/{stop-DPEhunlw.mjs → stop-Dky10AEJ.mjs}

@@ -1,9 +1,9 @@
-import { j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { c as writeWorkspaceState, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { m as runningBundleInstances } from "./workspaces-C36s2jb9.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-4WopRPg-.mjs";
-import { a as macosRuntimeClaim, o as requiredMacosRecord } from "./state-CG_OFoaA.mjs";
-import { n as stopHostedMacos } from "./hosted-macos-BACVAVqE.mjs";
+import { 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 { d as writeWorkspaceState, l as withWorkspaceStateLockAsync } from "./workspace-state-U08dEzhG.mjs";
+import { a as macosRuntimeClaim, o as requiredMacosRecord } from "./state-08I3hw3_.mjs";
+import { C as runningBundleInstancesAsync } from "./workspaces-CpANmBlq.mjs";
+import { n as stopHostedMacos } from "./hosted-macos-_awYSpfv.mjs";
 import { readMacosRecord } from "@stim-cli/core/state";
 //#region src/macos/stop.ts
 const APP_EXIT_MS = 5e3;
@@ -15,57 +15,67 @@ function signal(pid, name) {
 		if (error.code !== "ESRCH") throw error;
 	}
 }
-async function stopProcesses(records, waitMs = APP_EXIT_MS) {
+async function stopProcesses(records, waitMs = APP_EXIT_MS, operation) {
 	let live = [...new Map(records.map((record) => [record.pid, record])).values()];
 	for (const name of ["SIGTERM", "SIGKILL"]) {
+		operation?.signal.throwIfAborted();
 		live = live.filter((record) => {
 			const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
 			if (identity === "gone" || identity === "different") return false;
 			if (identity !== "same") throw Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS owner pid ${record.pid}; no signal was sent.`), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
 			return true;
 		});
-		for (const record of live) signal(record.pid, name);
-		const exited = await Promise.all(live.map((record) => (0, process_identity_exports.waitForProcessExit)(record, waitMs)));
+		for (const record of live) {
+			operation?.signal.throwIfAborted();
+			signal(record.pid, name);
+		}
+		const exited = await Promise.all(live.map((record) => (0, process_identity_exports.waitForProcessExit)(record, waitMs, operation?.signal)));
 		live = live.filter((_, index) => !exited[index]);
 		if (!live.length) return;
 	}
 	throw new Error(`Owned macOS process ${live.map((record) => record.pid).join(", ")} did not exit.`);
 }
 /** Stops every running copy of the workspace's owned app bundle, including copies LaunchServices started. */
-async function stopBundleInstances(root) {
-	const instances = runningBundleInstances(root);
-	await stopProcesses(instances);
+async function stopBundleInstances(root, operation) {
+	const instances = await runningBundleInstancesAsync(root, operation);
+	await stopProcesses(instances, void 0, operation);
 	return instances.length > 0;
 }
-async function stopMacosAppHeld(root) {
+async function stopMacosAppHeld(root, operation) {
+	operation?.signal.throwIfAborted();
 	const record = requiredMacosRecord(root);
-	if (record?.supervisor) await stopProcesses([record.supervisor], SUPERVISOR_EXIT_MS);
+	if (record?.supervisor) await stopProcesses([record.supervisor], SUPERVISOR_EXIT_MS, operation);
 	const app = readMacosRecord(root)?.app ?? record?.app;
-	if (app) await stopProcesses([app]);
-	const instances = runningBundleInstances(root);
-	await stopProcesses(instances);
+	if (app) await stopProcesses([app], void 0, operation);
+	const instances = await runningBundleInstancesAsync(root, operation);
+	await stopProcesses(instances, void 0, operation);
+	operation?.signal.throwIfAborted();
 	if (!record) return instances.length > 0;
 	const claims = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
 	if (claims.unresolved.length || claims.live.length) throw Object.assign(/* @__PURE__ */ new Error("The macOS runtime claim cannot be released; inspect its recorded owner before cleanup."), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
 	return true;
 }
 /** Stops the workspace's app here, or its session on the hosting Mac, which must confirm the session stopped. */
-function stopMacosApp(root) {
+function stopMacosApp(root, operation) {
 	const stop = async () => {
+		operation?.signal.throwIfAborted();
 		const record = requiredMacosRecord(root);
-		if (!record?.host) return stopMacosAppHeld(root);
-		await stopHostedMacos(root, record.host);
+		if (!record?.host) return stopMacosAppHeld(root, operation);
+		await stopHostedMacos(root, record.host, operation?.signal);
+		operation?.signal.throwIfAborted();
 		const { host: _host, hostLaunched: _launched, ...stopped } = record;
-		writeWorkspaceState(root, { macos: {
+		await withWorkspaceStateLockAsync(root, () => writeWorkspaceState(root, { macos: {
 			...stopped,
 			supervisor: void 0
-		} });
+		} }), operation?.signal);
 		return true;
 	};
 	return withWorkspaceProcessLock(workspaceDir(root), "macos-launch", stop, {
 		external: true,
 		waitMs: 0,
-		ownerPurpose: "stop macOS app"
+		ownerPurpose: "stop macOS app",
+		signal: operation?.signal,
+		declareSpawnsFor: operation
 	});
 }
 //#endregion