stim 1.21.0 → 1.22.0

package/dist/{macos-C-0qJ6zq.mjs → macos-NfV2D7dO.mjs}

@@ -1,30 +1,32 @@
-import { d as withDrainingCancellation, p as process_identity_exports, s as spawnDeclared, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { d as spawnDeclared, h as withDrainingCancellation, i as withWorkspaceProcessLock, t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { d as workspaceDir, l as workspaceAgentDeviceDir, m as workspaceLogsDir$1, n as ensureWorkspaceStorage } from "./paths-DQtTgsBf.mjs";
-import { E as upsertProject, u as getConcurrencyLimits } from "./config-CYcBF478.mjs";
-import { l as phaseLine } from "./command-output-B1UrjZHL.mjs";
-import { d as writeWorkspaceState, i as recordWorkspaceUse } from "./workspace-state-Cjuigeeu.mjs";
-import { J as resolveProjectSettingsAsync, a as SETTING_SHAPE_REMEDY, en as throwIfCancelled, et as settingShapeErrors } from "./settings-CsJDEXgK.mjs";
-import { f as projectRegistry, i as findProjectRoot$1, s as ownedDeviceLabel } from "./project-BZNjmW_8.mjs";
-import { i as macosProcess, n as macosDir, o as requiredMacosRecord, r as macosLogFile } from "./state-XMziexv2.mjs";
+import { E as upsertProject, u as getConcurrencyLimits } from "./config-DlrsduwG.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { d as writeWorkspaceState, i as recordWorkspaceUse } from "./workspace-state-U08dEzhG.mjs";
+import { J as resolveProjectSettingsAsync, a as SETTING_SHAPE_REMEDY, et as settingShapeErrors } from "./settings-C7O8A6ZI.mjs";
+import { f as projectRegistry, i as findProjectRoot$1, s as ownedDeviceLabel } from "./project-wM_XFTvE.mjs";
+import { i as macosProcess, n as macosDir, o as requiredMacosRecord, r as macosLogFile } from "./state-08I3hw3_.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
-import { B as recordFinishedBuild, Fn as processContext, H as tapBuildLog, In as runProcessOperation, M as NO_BUILD_PROGRESS, V as startBuildProgress, z as recordBuildPhase } from "./budget-Bs6SxxzO.mjs";
-import { d as runCancellationSignal, f as withNativeBuildRun } from "./native-run-DY_RLx3C.mjs";
-import { F as acquireBuildSlot, L as releaseBuildSlot } from "./workspaces-BccMFmGQ.mjs";
-import { D as sanitizeDeviceLabel } from "./ios-CpByZy12.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
-import { c as offloadPlacement, f as setRemoteLogSink, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, r as chooseBuildMachine, u as remotePhaseText } from "./client-UXD70ZbM.mjs";
-import { a as requireLocalBuild, i as parseBuildMachineOption, r as namedBuildMachine, s as resolveBuildPlacement, t as OffloadRefusal } from "./selection-CSl9i5qU.mjs";
-import { l as connectHost } from "./hosted-client-DB_gBPfY.mjs";
-import { t as placeHostedMacos } from "./hosted-macos-QI141yKk.mjs";
-import { r as stopMacosAppHeld, t as stopBundleInstances } from "./stop-D7h6jAXQ.mjs";
+import { B as recordFinishedBuild, Fn as processContext, H as tapBuildLog, In as runProcessOperation, M as NO_BUILD_PROGRESS, V as startBuildProgress, z as recordBuildPhase } from "./budget-Cvwn54qV.mjs";
+import { d as runCancellationSignal, f as withNativeBuildRun } from "./native-run-NwUuxbkg.mjs";
+import { I as acquireBuildSlot, R as releaseBuildSlot } from "./workspaces-CpANmBlq.mjs";
+import { D as sanitizeDeviceLabel } from "./ios-hcBpnEGk.mjs";
+import { c as offloadPlacement, h as setRemoteLogSink, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, r as chooseBuildMachine, u as remotePhaseText } from "./client-OyRoEuSr.mjs";
+import { a as requireLocalBuild, i as parseBuildMachineOption, r as namedBuildMachine, s as resolveBuildPlacement, t as OffloadRefusal } from "./selection-DSMbWEX2.mjs";
+import { l as connectHost } from "./hosted-client-DZAPrcro.mjs";
+import { t as placeHostedMacos } from "./hosted-macos-_awYSpfv.mjs";
+import { r as stopMacosAppHeld, t as stopBundleInstances } from "./stop-Dky10AEJ.mjs";
 import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
-import { t as buildPlacementRecord } from "./placement-log-BqGbTa61.mjs";
-import { i as validateInfoPlist, t as resolveBundleExtras } from "./stage-BIS0ydsV.mjs";
+import { t as buildPlacementRecord } from "./placement-log-BnGgJRRZ.mjs";
+import { t as reidentifyBundle } from "./stage-Bps5oius.mjs";
+import { t as validateMacosArtifactPlatform } from "./artifact-platform-CXcmX_j3.mjs";
+import { t as waitForMacosRegistration } from "./registration-BcRgF6Ox.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { closeSync, existsSync, openSync, promises, realpathSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { LOG_ROTATE_BYTES, ambientEnv } from "@stim-cli/core";
-import { machineCapacity, readMacosRecord, validHostedAppArguments } from "@stim-cli/core/state";
+import { machineCapacity, validHostedAppArguments } from "@stim-cli/core/state";
 //#region src/macos/build.ts
 async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displayName, scratch, writer, note, record, buildMachine, progress = NO_BUILD_PROGRESS }) {
 	const signal = runCancellationSignal(context) ?? context.signal;
@@ -87,9 +89,76 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 			}
 		};
 		let choice = null;
+		let retainStaging = false;
+		let identity = null;
+		const save = async (path) => {
+			if (!recipe.cache || !identity) return;
+			try {
+				if ((await recipe.cache.identity()).hash !== identity.hash) {
+					if (record) {
+						delete record.fingerprint;
+						delete record.cacheKey;
+					}
+					write("macOS inputs changed during the build; installing without caching.");
+					return;
+				}
+				const directory = join(staging, "cache-store");
+				await promises.mkdir(directory);
+				await recipe.cache.store(identity.key, path, directory);
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
+				throwIfCancelled(signal, "macOS cache store");
+				write(`macOS cache store skipped: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		};
 		try {
+			if (record) record.cacheHit = false;
+			if (recipe.cache) try {
+				identity = await recipe.cache.identity();
+				if (record) {
+					record.fingerprint = identity.hash;
+					record.cacheKey = identity.key;
+				}
+				const hit = await recipe.cache.restore(identity.key, join(staging, "cache-read"));
+				if (hit && (await recipe.cache.identity()).hash === identity.hash) {
+					await reidentifyBundle(context, hit.bundle, bundleId, displayName);
+					await recipe.validateFetched(hit.bundle, bundleId, displayName);
+					throwIfCancelled(signal, "macOS cache restore");
+					promote(hit.bundle);
+					if (record) {
+						record.cacheHit = true;
+						record.cacheSource = hit.tier;
+					}
+					write(`macOS cache hit (${hit.tier})`);
+					return {
+						bundleId,
+						offloadedTo: null,
+						offloadFallback: null,
+						handoff: null
+					};
+				}
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
+				throwIfCancelled(signal, "macOS cache lookup");
+				write(`macOS cache lookup skipped: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			let cacheOnly = false;
 			try {
 				const { mode, machines, localEnabled } = buildPlacementCandidates(buildMachine);
+				const peer = recipe.cache?.peer?.() ?? null;
+				const request = {
+					...recipe.offload.request(bundleId),
+					...peer ? {
+						artifactInputs: peer.inputs,
+						cacheArtifact: peer.write
+					} : {}
+				};
 				const here = machineCapacity();
 				const placement = offloadPlacement({
 					mode,
@@ -99,7 +168,8 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 					unsupported: null,
 					selected: buildMachine
 				});
-				if (placement.offload) {
+				cacheOnly = !placement.offload && placement.code === "this-mac-free" && peer !== null;
+				if (placement.offload || cacheOnly) {
 					const chosen = await chooseBuildMachine({
 						projectRoot: root,
 						target: await recipe.offload.target(),
@@ -108,7 +178,9 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 						machines,
 						selected: buildMachine,
 						note: (line) => write(`offload: ${line}`),
-						onCandidates: (each) => asked = each
+						onCandidates: (each) => asked = each,
+						cacheOnly,
+						...peer ? { swiftpmArtifact: request } : {}
 					});
 					if (typeof chosen === "string") throw new Error(chosen);
 					choice = chosen;
@@ -125,7 +197,7 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 					write(`placement: ${choice.machine} (${placement.reason}${placementLoad(choice)})`);
 					const outcome = await offloadBuild({
 						choice,
-						request: recipe.offload.request(bundleId),
+						request,
 						stagingDir: join(staging, "offload"),
 						onPhase: (phase, line) => note(remotePhaseText(phase, line, choice.machine)),
 						onEnter: (phase) => {
@@ -150,12 +222,20 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 					progress.place(null);
 					if (!outcome.ok) throw new Error(`${outcome.machine}: ${outcome.reason}`);
 					progress.step("install");
+					if (outcome.cacheHit) {
+						await reidentifyBundle(context, outcome.artifactPath, bundleId, displayName);
+						await validateMacosArtifactPlatform(context, outcome.artifactPath, recipe.product, signal);
+					}
 					await recipe.validateFetched(outcome.artifactPath, bundleId, displayName);
 					throwIfCancelled(signal, "macOS build");
 					promote(outcome.artifactPath);
 					if (record) {
+						delete record.fingerprint;
+						delete record.cacheKey;
 						record.offloadedTo = outcome.machine;
 						record.builtOn = outcome.machine;
+						record.cacheHit = outcome.cacheHit === true;
+						if (outcome.cacheHit) record.cacheSource = "peer";
 					}
 					return {
 						bundleId,
@@ -174,8 +254,13 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 				}));
 				write(`placement: here (${placement.reason})`);
 			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
 				throwIfCancelled(signal, "macOS build");
-				fallBack(error instanceof Error ? error.message : String(error));
+				if (cacheOnly) write(`placement: here (no reusable peer artifact)`);
+				else fallBack(error instanceof Error ? error.message : String(error));
 			} finally {
 				if (choice) closeOffload(choice);
 			}
@@ -202,6 +287,9 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 				const staged = join(staging, `${recipe.product}.app`);
 				await recipe.stage(bin, staged, bundleId, displayName);
 				throwIfCancelled(signal, "macOS build");
+				releaseBuildSlot(slot);
+				slot = void 0;
+				await save(staged);
 				promote(staged);
 				return {
 					bundleId,
@@ -214,7 +302,7 @@ async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displ
 			}
 		} finally {
 			try {
-				await promises.rm(staging, {
+				if (!retainStaging) await promises.rm(staging, {
 					recursive: true,
 					force: true
 				});
@@ -247,24 +335,36 @@ async function planMacos(context, root, buildMachineFlag) {
 	if (process.platform !== "darwin") throw new Error("stim macos requires a Mac with Swift installed.");
 	root = realpathSync(root);
 	if (!existsSync(join(root, "Package.swift"))) throw new Error("Run stim macos from the directory containing Package.swift.");
-	const { context: projectContext, settings } = await resolveProjectSettingsAsync(root);
+	const { settings } = await resolveProjectSettingsAsync(root, {
+		env: context.env,
+		signal: context.signal
+	});
 	const [shape] = settingShapeErrors(settings);
 	if (shape) throw new Error(`${shape} ${SETTING_SHAPE_REMEDY}`);
 	const selected = resolveBuildPlacement(buildMachineFlag);
 	if (selected.failure) throw Object.assign(new Error(selected.failure.message), selected.failure);
 	const macos = settings.macos;
 	if (!macos?.product || !macos.infoPlist) throw Object.assign(/* @__PURE__ */ new Error("Set macos.product and macos.infoPlist explicitly in .stim.json. See stim guide macos."), { code: "STIM_BAD_ARG" });
-	await validateInfoPlist(context, root, macos.product, macos.infoPlist);
-	resolveBundleExtras(root, projectContext.repoRoot ?? root, macos.resources, macos.assetCatalog);
+	const { swiftpmMacosProject } = await import("./swiftpm-macos-BIak-Rxv.mjs");
+	const recipe = await swiftpmMacosProject(root).prepare(context, settings);
+	let identity = null;
+	let cacheHit = false;
+	if (recipe.cache) try {
+		identity = await recipe.cache.identity();
+		cacheHit = await recipe.cache.has(identity.key);
+	} catch (error) {
+		if (error instanceof Error && "reportCleanup" in error) throw error;
+		context.signal.throwIfAborted();
+	}
 	return {
 		platform: "macos",
 		product: macos.product,
 		buildMachine: selected.selected,
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
+		fingerprint: identity?.hash ?? null,
+		cacheKey: identity?.key ?? null,
+		cacheHit,
 		provider: null,
-		cacheSkipped: false,
+		cacheSkipped: identity === null,
 		prebuild: null,
 		outcome: null,
 		expectedMs: null,
@@ -471,10 +571,10 @@ function recordMacosBuild(root, build, compileSteps) {
 		platform: "macos",
 		status: build.state === "ok" ? "ok" : "failed",
 		configuration: "Debug",
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		cacheSkipped: false,
+		fingerprint: build.fingerprint ?? null,
+		cacheKey: build.cacheKey ?? null,
+		cacheHit: build.cacheHit ? build.cacheSource === "provider" ? "remote" : "local" : false,
+		cacheSkipped: !build.cacheKey,
 		durationMs: build.durationMs,
 		startedAt: build.startedAt,
 		errorCode: build.errorCode,
@@ -514,7 +614,8 @@ async function launchHere(context, root, record, note) {
 			stdio: [
 				"ignore",
 				fd,
-				fd
+				fd,
+				"ipc"
 			],
 			env: {
 				...ambientEnv(),
@@ -526,14 +627,10 @@ async function launchHere(context, root, record, note) {
 		closeSync(fd);
 	}
 	const deadline = Date.now() + 2e4;
-	while (Date.now() < deadline) {
-		const current = readMacosRecord(root);
-		if (current?.launchId === record.launchId && current.app && current.supervisor && (0, process_identity_exports.inspectProcessIdentity)(current.app) === "same" && (0, process_identity_exports.inspectProcessIdentity)(current.supervisor) === "same") {
-			if (await waitForLaunchServices(current, deadline) === "timeout") note("macOS LaunchServices does not list the app yet. agent-device open may start a second copy; wait and check lsappinfo.");
-			return current;
-		}
-		if (child.exitCode !== null || child.signalCode !== null) break;
-		await new Promise((done) => setTimeout(done, 100));
+	const current = await waitForMacosRegistration(root, record.launchId, child, deadline);
+	if (current) {
+		if (await waitForLaunchServices(current, deadline) === "timeout") note("macOS LaunchServices does not list the app yet. agent-device open may start a second copy; wait and check lsappinfo.");
+		return current;
 	}
 	throw new Error("The macOS app did not register. See macos-supervisor.log in the workspace logs.");
 }
@@ -594,4 +691,4 @@ function macosCommand(program) {
 	});
 }
 //#endregion
-export { buildMacosBundle as i, runMacos as n, waitForLaunchServices as r, macosCommand as t };
+export { buildMacosBundle as a, planMacos as i, runMacos as n, waitForLaunchServices as r, macosCommand as t };

package/dist/macos-run.mjs

@@ -1,2 +1,2 @@
-import { n as runMacosSupervisor, t as logLines } from "./run-D23HmJMs.mjs";
+import { n as runMacosSupervisor, t as logLines } from "./run-DidHghD1.mjs";
 export { logLines, runMacosSupervisor };

package/dist/maintenance-run.mjs

@@ -1,19 +1,19 @@
-import { P as formatBytes } from "./config-CYcBF478.mjs";
-import { Tt as deviceSweepIsScoped, u as resolveBudget } from "./budget-Bs6SxxzO.mjs";
-import { I as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-CpByZy12.mjs";
-import { h as maintenanceLogger } from "./client-UXD70ZbM.mjs";
+import { P as formatBytes } from "./config-DlrsduwG.mjs";
+import { Tt as deviceSweepIsScoped, u as resolveBudget } from "./budget-Cvwn54qV.mjs";
+import { I as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-hcBpnEGk.mjs";
+import { v as maintenanceLogger } from "./client-OyRoEuSr.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
-import { A as lowestFree, C as measurePressure, D as diskPressureLevel, E as sizeScanDeferred, O as levelFloors, S as measureDisk, T as measureSizes, k as levelStillShort } from "./worktree-DQ6Zi2Mv.mjs";
-import { i as plannedMaintenance, m as measureOwnedDevices, n as diskRecovered, o as triggeringRoot, r as executeAction } from "./act-DHAw2A2S.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-DFRyG1_o.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-BwNEtIrP.mjs";
+import { A as levelFloors, C as measureDisk, D as measureSizes, M as lowestFree, O as sizeScanDeferred, T as measurePressure, j as levelStillShort, k as diskPressureLevel } from "./worktree-CHecZ4Oq.mjs";
+import { i as plannedMaintenance, m as measureOwnedDevices, n as diskRecovered, o as triggeringRoot, r as executeAction } from "./act-DsuqEkiM.mjs";
 import { r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
+import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import { randomBytes } from "node:crypto";
 import { appendFileSync, mkdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { withDirLock } from "@stim-cli/core";
 import { maintenanceChildLogFile, maintenanceDir, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
-import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 //#region src/maintenance/run.ts
 function writeState(state) {
 	mkdirSync(maintenanceDir(), { recursive: true });

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

@@ -1,6 +1,7 @@
-import { p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
-import { F as isOnMountedVolume, I as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-CYcBF478.mjs";
-import { r as readWorkspaceState } from "./workspace-state-Cjuigeeu.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";
@@ -224,15 +225,19 @@ function isMetroRunning(port, signal) {
 	});
 }
 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();
@@ -247,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.`);
@@ -315,7 +325,7 @@ function listeningPids(port, platform = process.platform) {
 	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) {
+async function listeningPidsAsync(port, platform = process.platform, signal) {
 	const pids = parseLsofPids(await getExecutor().runFileQuietAsync("lsof", [
 		"-nP",
 		`-iTCP:${port}`,
@@ -323,12 +333,14 @@ async function listeningPidsAsync(port, platform = process.platform) {
 		"-t"
 	], {
 		timeoutMs: 1e4,
-		killSignal: "SIGKILL"
+		killSignal: "SIGKILL",
+		signal
 	}));
 	if (pids.length > 0 || platform !== "win32") return pids;
 	return parseNetstatPids(await getExecutor().runFileQuietAsync("netstat", ["-ano"], {
 		timeoutMs: 1e4,
-		killSignal: "SIGKILL"
+		killSignal: "SIGKILL",
+		signal
 	}), port);
 }
 function parseLsofCwd(out) {
@@ -339,10 +351,11 @@ function parseLsofCwd(out) {
 	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
 	return nLine ? nLine.slice(1) : null;
 }
-function lsofOutput(args) {
+function lsofOutput(args, signal) {
 	return getExecutor().runFileAsync("lsof", args, {
 		timeoutMs: 1e4,
-		killSignal: "SIGKILL"
+		killSignal: "SIGKILL",
+		signal
 	}).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
 }
 /**
@@ -375,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)) {
@@ -394,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);
@@ -488,21 +501,24 @@ function signalProcessTree(pid, signal = "SIGTERM", { group = false, platform =
 		"/F"
 	], { timeoutMs: 3e4 }) !== null;
 }
-function killMetroTree(leader, processToken) {
-	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 false;
-	}
-}
 /** 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),
@@ -514,16 +530,22 @@ async function signalProcessTreeAsync(pid, signal = "SIGTERM", options = {}) {
 	}) !== null;
 }
 /** Stops the verified Metro process tree without blocking on Windows taskkill. */
-async function killMetroTreeAsync(leader, processToken) {
+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 await signalProcessTreeAsync(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 { reserveMetroPort as _, listeningPids as a, parseNetstatPids as c, processCwds as d, resolveProjectMetro as f, isMetroRunning as g, createPortProbe as h, killMetroTreeAsync as i, pidExists as l, signalProcessTreeAsync as m, isInsideProject as n, listeningPidsAsync as o, signalProcessTree as p, killMetroTree as r, listeningPidsByPort as s, NOT_OURS_FOREIGN_CWD as t, processCwd as u, PORT_INSPECTION_REMEDY as v, PortInspectionError as y };
+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 };