stim 1.20.2 → 1.22.0

package/dist/{metro-DnCEjCxs.mjs → metro-DiXtA3Ty.mjs}

@@ -1,6 +1,7 @@
-import { F as listMountedVolumes, P as isOnMountedVolume, _ as loadConfig, k as process_identity_exports, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as readWorkspaceState } from "./workspace-state-DJt_MMvf.mjs";
+import { g as process_identity_exports, r as WorkspaceProcessCleanupError, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { F as isOnMountedVolume, I as listMountedVolumes, O as withConfigLockAsync, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-DlrsduwG.mjs";
+import { t as runOperationFile } from "./operation-exec-BW0em61G.mjs";
+import { r as readWorkspaceState } from "./workspace-state-U08dEzhG.mjs";
 import { sep } from "path";
 import { existsSync, readlinkSync, realpathSync } from "fs";
 import { readFile } from "node:fs/promises";
@@ -192,38 +193,51 @@ function createPortProbe() {
 		throw new PortInspectionError(`Cannot tell whether TCP port ${port} is free: the TCP listener table failed (${listening.message.replace(/\s+/g, " ").trim()}), lsof could not list listeners, and a loopback connect failed.`);
 	};
 }
-function isMetroRunning(port) {
+function isMetroRunning(port, signal) {
 	return new Promise((resolve) => {
 		const req = request({
 			hostname: "localhost",
 			port,
 			path: "/status",
-			timeout: 2e3
+			timeout: 2e3,
+			signal
 		}, (res) => {
 			let data = "";
+			let bytes = 0;
 			res.on("data", (chunk) => {
+				bytes += Buffer.byteLength(chunk);
+				if (bytes > 65536) return finish(false);
 				data += chunk;
 			});
-			res.on("end", () => resolve(data.includes("packager-status:running")));
+			res.on("end", () => finish(data.includes("packager-status:running")));
+			res.on("error", () => finish(false));
+			res.on("aborted", () => finish(false));
 		});
-		req.on("error", () => resolve(false));
-		req.on("timeout", () => {
+		const deadline = setTimeout(() => finish(false), 2e3);
+		const finish = (running) => {
+			clearTimeout(deadline);
 			req.destroy();
-			resolve(false);
-		});
+			resolve(running);
+		};
+		req.on("error", () => finish(false));
+		req.on("timeout", () => finish(false));
 		req.end();
 	});
 }
 const FIRST_PORT = 8082;
-async function computeNextPort(isFree = createPortProbe()) {
+async function computeNextPort(isFree = createPortProbe(), signal) {
+	signal?.throwIfAborted();
 	const taken = new Set(allMetroPorts());
 	for (let port = FIRST_PORT; port < 8282; port++) {
 		if (taken.has(port)) continue;
-		if (await isFree(port)) return port;
+		const free = await isFree(port);
+		signal?.throwIfAborted();
+		if (free) return port;
 	}
 	throw new Error(`Found no free Metro port between ${FIRST_PORT} and 8281. Free one up, or stop a stale bundler (\`stim status\`, \`stim stop <port>\`).`);
 }
-async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, { isMounted = isOnMountedVolume, mountedVolumes } = {}) {
+async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, { isMounted = isOnMountedVolume, mountedVolumes, signal } = {}) {
+	signal?.throwIfAborted();
 	const cfg = loadConfig();
 	if (!cfg?.projects) return null;
 	const mounted = mountedVolumes || listMountedVolumes();
@@ -238,26 +252,31 @@ async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, {
 			ownerPath: path
 		});
 	}
-	for (const c of candidates) if (!await probe(c.port)) return c;
+	for (const c of candidates) {
+		const alive = await probe(c.port);
+		signal?.throwIfAborted();
+		if (!alive) return c;
+	}
 	return null;
 }
-async function allocatePort(projectPath, probe = isMetroRunning, isFree = createPortProbe()) {
-	const reclaim = await findReclaimablePort(projectPath, probe);
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = createPortProbe(), signal) {
+	const reclaim = await findReclaimablePort(projectPath, probe, { signal });
 	if (reclaim && await isFree(reclaim.port)) {
-		releaseMetroPort(reclaim.ownerPath, reclaim.port);
+		await withConfigLockAsync(() => releaseMetroPort(reclaim.ownerPath, reclaim.port), signal);
 		return reclaim.port;
 	}
-	return computeNextPort(isFree);
+	return computeNextPort(isFree, signal);
 }
 const RESERVE_ATTEMPTS = 5;
-async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree, pinned = null) {
+async function reserveMetroPort(projectPath, probe = (port) => isMetroRunning(port, signal), isFree, pinned = null, signal) {
+	signal?.throwIfAborted();
 	if (pinned !== null) {
-		if (claimMetroPort(projectPath, pinned) !== null) return pinned;
+		if (await withConfigLockAsync(() => claimMetroPort(projectPath, pinned), signal) !== null) return pinned;
 		throw new Error(`metro.port ${pinned} is already reserved by another workspace's Metro or named port.`);
 	}
 	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
-		const port = await allocatePort(projectPath, probe, isFree);
-		const claimed = claimMetroPort(projectPath, port);
+		const port = await allocatePort(projectPath, probe, isFree, signal);
+		const claimed = await withConfigLockAsync(() => claimMetroPort(projectPath, port), signal);
 		if (claimed !== null) return claimed;
 	}
 	throw new Error(`Could not reserve a Metro port after ${RESERVE_ATTEMPTS} attempts: another Stim run claimed each one first. Retry.`);
@@ -305,6 +324,25 @@ function listeningPids(port, platform = process.platform) {
 	if (pids.length > 0 || platform !== "win32") return pids;
 	return parseNetstatPids(getExecutor().runQuiet("netstat -ano", { timeoutMs: 1e4 }), port);
 }
+/** Reads listener pids without blocking on lsof or netstat. */
+async function listeningPidsAsync(port, platform = process.platform, signal) {
+	const pids = parseLsofPids(await getExecutor().runFileQuietAsync("lsof", [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:LISTEN",
+		"-t"
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL",
+		signal
+	}));
+	if (pids.length > 0 || platform !== "win32") return pids;
+	return parseNetstatPids(await getExecutor().runFileQuietAsync("netstat", ["-ano"], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL",
+		signal
+	}), port);
+}
 function parseLsofCwd(out) {
 	if (!out) return null;
 	const lines = String(out).split("\n");
@@ -313,8 +351,12 @@ function parseLsofCwd(out) {
 	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
 	return nLine ? nLine.slice(1) : null;
 }
-function lsofOutput(args) {
-	return getExecutor().runFileAsync("lsof", args, { timeoutMs: 1e4 }).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
+function lsofOutput(args, signal) {
+	return getExecutor().runFileAsync("lsof", args, {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL",
+		signal
+	}).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
 }
 /**
 * `listeningPids` for several ports with one lsof call. A port lsof could not be asked about is
@@ -346,7 +388,7 @@ function parseLsofCwds(out) {
 	return cwds;
 }
 /** `processCwd` for several pids with at most one lsof call. A pid lsof could not be asked about is missing from the map. */
-async function processCwds(pids) {
+async function processCwds(pids, signal) {
 	const cwds = /* @__PURE__ */ new Map();
 	const viaLsof = [];
 	for (const pid of new Set(pids)) {
@@ -365,7 +407,7 @@ async function processCwds(pids) {
 		"-d",
 		"cwd",
 		"-Fn"
-	]);
+	], signal);
 	if (out === null) return cwds;
 	const found = parseLsofCwds(out);
 	for (const pid of viaLsof) cwds.set(pid, found.get(pid) ?? null);
@@ -459,16 +501,51 @@ function signalProcessTree(pid, signal = "SIGTERM", { group = false, platform =
 		"/F"
 	], { timeoutMs: 3e4 }) !== null;
 }
-function killMetroTree(leader, processToken) {
+/** Signals a process tree without blocking on Windows taskkill. */
+async function signalProcessTreeAsync(pid, signal = "SIGTERM", options = {}) {
+	options.operation?.signal.throwIfAborted();
+	if (!Number.isSafeInteger(pid) || pid <= 1) throw new Error(`Refusing to signal pid ${pid}.`);
+	if ((options.platform ?? process.platform) !== "win32") return signalProcessTree(pid, signal, options);
+	if (options.operation) {
+		await runOperationFile(options.operation, getExecutor(), "taskkill", [
+			"/PID",
+			String(pid),
+			"/T",
+			"/F"
+		], {
+			cwd: options.operation.cwd,
+			timeoutMs: 3e4,
+			killSignal: "SIGKILL"
+		});
+		return true;
+	}
+	return await getExecutor().runFileQuietAsync("taskkill", [
+		"/PID",
+		String(pid),
+		"/T",
+		"/F"
+	], {
+		timeoutMs: 3e4,
+		killSignal: "SIGKILL"
+	}) !== null;
+}
+/** Stops the verified Metro process tree without blocking on Windows taskkill. */
+async function killMetroTreeAsync(leader, processToken, operation) {
+	operation?.signal.throwIfAborted();
 	if (!leader || leader === process.pid || (0, process_identity_exports.inspectProcessIdentity)({
 		pid: leader,
 		processToken
 	}) !== "same") return false;
 	try {
-		return signalProcessTree(leader, "SIGTERM", { group: true });
-	} catch {
+		return await signalProcessTreeAsync(leader, "SIGTERM", {
+			group: true,
+			operation
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return false;
 	}
 }
 //#endregion
-export { listeningPidsByPort as a, processCwd as c, signalProcessTree as d, createPortProbe as f, PortInspectionError as g, PORT_INSPECTION_REMEDY as h, listeningPids as i, processCwds as l, reserveMetroPort as m, isInsideProject as n, parseNetstatPids as o, isMetroRunning as p, killMetroTree as r, pidExists as s, NOT_OURS_FOREIGN_CWD as t, resolveProjectMetro as u };
+export { PORT_INSPECTION_REMEDY as _, listeningPidsAsync as a, pidExists as c, resolveProjectMetro as d, signalProcessTree as f, reserveMetroPort as g, isMetroRunning as h, listeningPids as i, processCwd as l, createPortProbe as m, isInsideProject as n, listeningPidsByPort as o, signalProcessTreeAsync as p, killMetroTreeAsync as r, parseNetstatPids as s, NOT_OURS_FOREIGN_CWD as t, processCwds as u, PortInspectionError as v };

package/dist/metro-gateway-CKZqKqx7.mjs

@@ -0,0 +1,209 @@
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { g as workspaceStateFile$1 } from "./paths-DQtTgsBf.mjs";
+import { ot as tailscaleStatusAsync } from "./config-DlrsduwG.mjs";
+import { d as cancelledError, f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-U08dEzhG.mjs";
+import { randomBytes, randomUUID } from "node:crypto";
+import { statSync, watch } from "node:fs";
+import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
+import { isIP } from "node:net";
+//#region src/workspace/workspace-state-watch.ts
+/** Filesystem events are hints; callers retain their own bounded repair and state verification. */
+function watchWorkspaceState(root, changed) {
+	let stopped = false;
+	let current;
+	let startup;
+	const clear = () => {
+		clearTimeout(startup);
+		const previous = current;
+		current = void 0;
+		previous?.watcher.close();
+	};
+	const refresh = () => {
+		if (stopped) return;
+		try {
+			const file = workspaceStateFile$1(root);
+			const stat = statSync(file);
+			if (current?.dev === stat.dev && current.ino === stat.ino) return;
+			clear();
+			const watcher = watch(file, { persistent: false }, () => {
+				if (stopped || current?.watcher !== watcher) return;
+				refresh();
+				changed();
+			});
+			current = {
+				watcher,
+				dev: stat.dev,
+				ino: stat.ino
+			};
+			const lost = () => {
+				if (current?.watcher === watcher) clear();
+			};
+			watcher.once("error", lost);
+			watcher.once("close", lost);
+			startup = setTimeout(() => {
+				if (stopped) return;
+				refresh();
+				changed();
+			}, 500);
+		} catch {
+			clear();
+		}
+	};
+	refresh();
+	return {
+		refresh,
+		close: () => {
+			stopped = true;
+			clear();
+		}
+	};
+}
+//#endregion
+//#region src/device-host/metro-gateway.ts
+async function waitForGateway(root, read, { waitMs, signal, what }) {
+	throwIfCancelled(signal, what);
+	const startedAt = Date.now();
+	const deadline = startedAt + waitMs;
+	let observer;
+	let timer;
+	let queued;
+	let onAbort;
+	try {
+		return await new Promise((resolve, reject) => {
+			const check = () => {
+				clearImmediate(queued);
+				queued = void 0;
+				clearTimeout(timer);
+				try {
+					throwIfCancelled(signal, what);
+					observer?.refresh();
+					const result = read();
+					const remaining = deadline - Date.now();
+					if (result !== null || remaining <= 0) resolve(result);
+					else {
+						const repairMs = Date.now() - startedAt < 500 ? 100 : 1e3;
+						timer = setTimeout(check, Math.min(remaining, repairMs));
+					}
+				} catch (error) {
+					reject(error);
+				}
+			};
+			onAbort = () => reject(cancelledError(what));
+			signal?.addEventListener("abort", onAbort, { once: true });
+			observer = watchWorkspaceState(root, () => {
+				queued ??= setImmediate(check);
+			});
+			check();
+		});
+	} finally {
+		observer?.close();
+		clearTimeout(timer);
+		clearImmediate(queued);
+		if (onAbort) signal?.removeEventListener("abort", onAbort);
+	}
+}
+function gatewayAddresses(credential, status) {
+	const machine = parseMachine(credential.machine);
+	const peer = machine ? findPeer(status, machine.name) : "missing";
+	if (typeof peer === "string") throw new Error(`${credential.machine} no longer resolves to one tailnet peer. Run stim doctor.`);
+	const self = isJsonObject(status) && isJsonObject(status.Self) ? status.Self : null;
+	const address = (Array.isArray(self?.TailscaleIPs) ? self.TailscaleIPs : []).find((ip) => typeof ip === "string" && isIP(ip) === isIP(peer.address) && isIP(ip) !== 0);
+	if (!address) throw new Error("This machine has no Tailscale address compatible with the hosting Mac.");
+	return {
+		address,
+		peer: peer.address
+	};
+}
+function requireHostedMetro(root) {
+	const supervisor = readWorkspaceState$1(root)?.supervisor;
+	if (supervisor?.hostedMetro === true && (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "same") return;
+	throw Object.assign(/* @__PURE__ */ new Error("Hosted Debug runs require a running Metro supervisor with private gateway support. Run stim stop; stim start, then retry."), {
+		code: "STIM_HOSTING_REFUSED",
+		remedy: "Run stim stop; stim start, then retry."
+	});
+}
+async function requestHostedMetro(root, session, credential, signal) {
+	throwIfCancelled(signal, "hosted Metro gateway");
+	requireHostedMetro(root);
+	const addresses = gatewayAddresses(credential, await tailscaleStatusAsync(signal));
+	throwIfCancelled(signal, "hosted Metro gateway");
+	requireHostedMetro(root);
+	const previous = hostedMetroRequests(readWorkspaceState$1(root))[session];
+	const request = previous && previous.address === addresses.address && previous.peer === addresses.peer ? previous : {
+		id: randomUUID(),
+		machine: credential.machine,
+		...addresses,
+		secret: randomBytes(32).toString("hex")
+	};
+	await updateWorkspaceStateAsync(root, (state) => ({
+		...state,
+		[HOSTED_METRO_REQUESTS_KEY]: {
+			...hostedMetroRequests(state),
+			[session]: request
+		}
+	}), signal);
+	const opened = await waitForGateway(root, () => {
+		const state = readWorkspaceState$1(root);
+		const gateway = hostedMetroGateways(state)[session];
+		if (gateway?.id === request.id && gateway.processToken === state?.supervisor?.processToken) {
+			if (gateway.error) throw new Error(gateway.error);
+			if (gateway.port) return {
+				gatewayPort: gateway.port,
+				secret: request.secret
+			};
+		}
+		return null;
+	}, {
+		waitMs: 15e3,
+		signal,
+		what: "hosted Metro gateway"
+	});
+	if (opened) return opened;
+	throw new Error(`The Metro supervisor did not open a private gateway for ${credential.machine}. Run stim stop; stim start, then retry.`);
+}
+function clearHostedMetro(root, session) {
+	updateWorkspaceState(root, (state) => {
+		const requests = { ...hostedMetroRequests(state) };
+		delete requests[session];
+		return {
+			...state,
+			[HOSTED_METRO_REQUESTS_KEY]: requests
+		};
+	});
+}
+async function closeHostedMetro(root, session, signal) {
+	await withWorkspaceStateLockAsync(root, () => clearHostedMetro(root, session), signal);
+	if (!await waitForGateway(root, () => {
+		const state = readWorkspaceState$1(root);
+		const gateway = hostedMetroGateways(state)[session];
+		const supervisor = state?.supervisor;
+		if (!gateway?.port || !supervisor || gateway.processToken !== supervisor.processToken) return true;
+		return (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "gone" ? true : null;
+	}, {
+		waitMs: 5e3,
+		signal,
+		what: "close hosted Metro"
+	})) throw new Error("The Metro supervisor did not close its private gateway. Restart Metro, then retry stim stop.");
+}
+function hostedMetroSettings(settings, hosted) {
+	return hosted ? {
+		...settings,
+		ios: {
+			...isJsonObject(settings.ios) ? settings.ios : {},
+			remote: void 0
+		},
+		android: {
+			...isJsonObject(settings.android) ? settings.android : {},
+			remote: void 0
+		},
+		metro: {
+			...isJsonObject(settings.metro) ? settings.metro : {},
+			tunnel: void 0,
+			publicUrl: void 0,
+			ngrokUrl: void 0
+		}
+	} : settings;
+}
+//#endregion
+export { requireHostedMetro as a, requestHostedMetro as i, closeHostedMetro as n, watchWorkspaceState as o, hostedMetroSettings as r, clearHostedMetro as t };

package/dist/{named-ports-4WopRPg-.mjs → named-ports-DkEzOfzO.mjs}

@@ -1,63 +1,7 @@
-import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, j as ownership_claim_exports, k as process_identity_exports, p as getProject } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { d as signalProcessTree, f as createPortProbe, o as parseNetstatPids } from "./metro-DnCEjCxs.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-DVS5RkMS.mjs";
+import { g as process_identity_exports, i as withWorkspaceProcessLock, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { C as saveConfig, O as withConfigLockAsync, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-DlrsduwG.mjs";
+import { f as signalProcessTree, m as createPortProbe, s as parseNetstatPids } from "./metro-DiXtA3Ty.mjs";
 import { realpathSync } from "node:fs";
-import { join } from "node:path";
-import { setTimeout } from "node:timers/promises";
-//#region src/engine/workspace-process-lock.ts
-const DEFAULT_WAIT_MS = 6e4;
-const POLL_MS = 25;
-function workspaceProcessLockError(err) {
-	const code = err?.code;
-	if (code === "STIM_LOCK_REFUSED") return "refused";
-	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
-	return null;
-}
-function workspaceProcessLockPath(root, name, external) {
-	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
-}
-async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
-	const path = workspaceProcessLockPath(root, name, external);
-	const deadline = now() + waitMs;
-	for (;;) {
-		signal?.throwIfAborted();
-		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-			root: path,
-			mode: "exclusive",
-			label: `${name} lock`,
-			details: ownerPurpose ? {
-				...details,
-				purpose: ownerPurpose
-			} : details
-		});
-		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		if (attempt.acquired) {
-			if (declareSpawns) declareSpawnsOn(attempt.acquired);
-			try {
-				return await fn(attempt.acquired);
-			} finally {
-				stopDeclaringSpawnsOn(attempt.acquired);
-				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
-			}
-		}
-		const holder = attempt.held ?? attempt.waitingFor?.[0];
-		const purpose = holder?.details.purpose;
-		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
-			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
-			error.code = "STIM_LOCK_REFUSED";
-			throw error;
-		}
-		if (holder && onHeld) await onHeld(holder);
-		if (now() >= deadline) {
-			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
-			error.code = "STIM_LOCK_TIMEOUT";
-			throw error;
-		}
-		await sleep(POLL_MS);
-	}
-}
-//#endregion
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;
 const LAST_PORT = 8999;
@@ -112,8 +56,11 @@ function processCommand(pid, platform) {
 		"args="
 	], { timeoutMs: 5e3 }) ?? "").trim();
 }
-function withPortsLock(fn) {
-	return withWorkspaceProcessLock(getConfigDir(), "ports", fn, { external: true });
+function withPortsLock(fn, signal) {
+	return withWorkspaceProcessLock(getConfigDir(), "ports", fn, {
+		external: true,
+		signal
+	});
 }
 async function getNamedPort(projectPath, label, options = {}) {
 	validatePortLabel(label);
@@ -123,14 +70,14 @@ async function getNamedPort(projectPath, label, options = {}) {
 function reserveBrowserPort(projectPath, options = {}) {
 	return allocateNamedPort(projectPath, BROWSER_LABEL, options);
 }
-function releaseBrowserPort(projectPath, port) {
-	return withPortsLock(async () => withConfigLock(() => {
+function releaseBrowserPort(projectPath, port, signal) {
+	return withPortsLock(() => withConfigLockAsync(() => {
 		const cfg = loadConfig();
 		const ports = cfg?.projects?.[projectPath]?.ports;
 		if (!cfg || ports?.[BROWSER_LABEL] !== port) return;
 		delete ports[BROWSER_LABEL];
 		saveConfig(cfg);
-	}));
+	}, signal), signal);
 }
 async function allocateNamedPort(projectPath, label, { isFree = createPortProbe() }) {
 	const root = realpathSync(projectPath);
@@ -140,7 +87,7 @@ async function allocateNamedPort(projectPath, label, { isFree = createPortProbe(
 		for (let port = FIRST_PORT; port <= LAST_PORT; port++) {
 			if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port || Object.values(project.ports ?? {}).includes(port))) continue;
 			if (!await isFree(port)) continue;
-			if (withConfigLock(() => {
+			if (await withConfigLockAsync(() => {
 				const cfg = ensureConfig();
 				if (Object.values(cfg.projects).some((project) => project.metroPort === port || Object.values(project.ports ?? {}).includes(port))) return false;
 				const project = cfg.projects[root] ??= {
@@ -158,9 +105,10 @@ async function allocateNamedPort(projectPath, label, { isFree = createPortProbe(
 		throw new Error(`No free named port between ${FIRST_PORT} and ${LAST_PORT}. Use stim ports stop or stim ports release in a workspace that no longer needs its ports.`);
 	});
 }
-async function stopListeners(port, label, dryRun, log, platform) {
+async function stopListeners(port, label, dryRun, log, platform, signal) {
 	const listeners = () => portListeners(port, platform);
 	for (const pid of listeners()) {
+		signal?.throwIfAborted();
 		if (pid === process.pid) throw new Error(`Refusing to stop Stim itself on ${label} (${port}).`);
 		const identity = (0, process_identity_exports.captureProcessIdentity)(pid);
 		if (!identity.ok) {
@@ -182,10 +130,10 @@ async function stopListeners(port, label, dryRun, log, platform) {
 		if (status !== "same") throw new Error(`Cannot verify pid ${pid} on ${label} (${port}); allocation kept.`);
 		try {
 			signalProcessTree(pid, "SIGTERM", { platform });
-			if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) {
+			if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3, signal)) {
 				if ((0, process_identity_exports.inspectProcessIdentity)(record) !== "same") throw new Error(`Cannot verify pid ${pid} before SIGKILL.`);
 				signalProcessTree(pid, "SIGKILL", { platform });
-				if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) throw new Error(`Pid ${pid} did not exit.`);
+				if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3, signal)) throw new Error(`Pid ${pid} did not exit.`);
 			}
 		} catch (error) {
 			if (error.code !== "ESRCH") throw error;
@@ -194,36 +142,40 @@ async function stopListeners(port, label, dryRun, log, platform) {
 	}
 	if (!dryRun && listeners().length) throw new Error(`Port ${port} still has a listener; allocation kept.`);
 }
-async function clearNamedPorts(projectPath, { label, stop = false, dryRun = false, log = console.error, platform = process.platform } = {}) {
+async function clearNamedPorts(projectPath, { label, stop = false, dryRun = false, log = console.error, platform = process.platform, signal } = {}) {
 	if (label !== void 0) validatePortLabel(label);
 	await withPortsLock(async () => {
 		const ports = getProject(projectPath)?.ports ?? {};
 		const selected = Object.entries(ports).filter(([name]) => name !== BROWSER_LABEL && (label === void 0 || name === label));
 		if (stop && selected.length > 0 && platform !== "win32" && !getExecutor().findExecutable("lsof")) throw new Error("Cannot stop named ports: lsof is not installed.");
 		const failures = [];
-		for (const [name, port] of selected) try {
-			if (!Number.isInteger(port) || port < FIRST_PORT || port > LAST_PORT) throw new Error(`Invalid named port ${name} (${port}); repair its config record before cleanup.`);
-			if (stop) {
-				if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port)) throw new Error(`Port ${port} is reserved for managed Metro; allocation kept.`);
-				await stopListeners(port, name, dryRun, log, platform);
-			}
-			if (dryRun) {
-				log(`would release ${name} (${port})`);
-				continue;
+		for (const [name, port] of selected) {
+			signal?.throwIfAborted();
+			try {
+				if (!Number.isInteger(port) || port < FIRST_PORT || port > LAST_PORT) throw new Error(`Invalid named port ${name} (${port}); repair its config record before cleanup.`);
+				if (stop) {
+					if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port)) throw new Error(`Port ${port} is reserved for managed Metro; allocation kept.`);
+					await stopListeners(port, name, dryRun, log, platform, signal);
+				}
+				if (dryRun) {
+					log(`would release ${name} (${port})`);
+					continue;
+				}
+				await withConfigLockAsync(() => {
+					const cfg = loadConfig();
+					const current = cfg?.projects?.[projectPath]?.ports;
+					if (!cfg || current?.[name] !== port) return;
+					delete current[name];
+					saveConfig(cfg);
+				}, signal);
+				log(`released ${name} (${port})`);
+			} catch (error) {
+				signal?.throwIfAborted();
+				failures.push(`${name} (${port}): ${error.message}`);
 			}
-			withConfigLock(() => {
-				const cfg = loadConfig();
-				const current = cfg?.projects?.[projectPath]?.ports;
-				if (!cfg || current?.[name] !== port) return;
-				delete current[name];
-				saveConfig(cfg);
-			});
-			log(`released ${name} (${port})`);
-		} catch (error) {
-			failures.push(`${name} (${port}): ${error.message}`);
 		}
 		if (failures.length) throw new Error(failures.join("\n"));
-	});
+	}, signal);
 }
 //#endregion
-export { withWorkspaceProcessLock as a, reserveBrowserPort as i, getNamedPort as n, workspaceProcessLockError as o, releaseBrowserPort as r, workspaceProcessLockPath as s, clearNamedPorts as t };
+export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };