stim 1.14.0 → 1.16.0

package/dist/device-ios-BadmeL2V.mjs

@@ -0,0 +1,381 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { C as saveConfig, D as withConfigLock, H as projectDeviceSlots, _ as loadConfig, a as clearDevice, d as getConfigDir, w as setDevice, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { y as iosSimSlimProfileSetting } from "./settings-oTSkkNrM.mjs";
+import { y as workspaceId } from "./workspace-state-B8-aJ1_5.mjs";
+import { ct as dropParked, ft as parkedMaxSetting, ht as selectParked, pt as readParked, st as adoptParked } from "./android-B_NumVyQ.mjs";
+import { A as hostMemoryPressureAdvice, C as resolveIosCreation, O as configuredIosSimulatorViewer, S as resetIosPrivacy, _ as parseRuntimeVersion, b as renameIosSim, f as listIosDeviceTypes, h as ownedSimName, i as createOwnedIosSim, j as readHostMemoryPressure, l as iosSimulatorFailureAdvice, n as bootIosSim, p as listIosRuntimes, u as listAllIosSims, w as resolveOwnedIosSim, x as resetIosKeychain } from "./ios-BaInn3sW.mjs";
+import { c as teardownParkedIosSim } from "./teardown-CL6vDs2Y.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { a as runtimeMismatch, n as deviceTypeMismatch } from "./device-capacity-BHwxNBlu.mjs";
+import chalk from "chalk";
+//#region src/engine/device-ios.ts
+function startIosBoot(udid, configure, label, out, simulatorApp) {
+	const done = (async () => {
+		await bootIosSim(udid, {
+			label,
+			out,
+			simulatorApp
+		});
+		await configure();
+	})();
+	done.catch(() => {});
+	return {
+		udid,
+		done
+	};
+}
+var IosDeviceMismatchError = class extends Error {
+	remedy = "Run `stim worktree remove` (or `stim gc --delete`) to reap the current sim, then `stim ios` again to create the requested one, or pass `--slot <name>` to create it beside the current one.";
+};
+async function ensureOwnedIosDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, reconcileIosSimulator }) {
+	const memoryAdvice = hostMemoryPressureAdvice(readHostMemoryPressure());
+	if (memoryAdvice) out(chalk.yellow(phaseLine("memory", memoryAdvice)));
+	const simslimProfile = iosSimSlimProfileSetting(settings, settingsRoot);
+	if (record?.deviceUdid) {
+		if (record.owned) {
+			const resolved = resolveOwnedIosSim(record.deviceUdid);
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned -- creating a fresh owned sim instead of booting it.`));
+			else if (resolved.missing) {} else {
+				const sim = resolved.sim;
+				const wantedType = flags.deviceType || settings?.ios?.deviceType;
+				const deviceTypes = listIosDeviceTypes();
+				const mismatch = deviceTypeMismatch(sim.deviceTypeIdentifier, wantedType, deviceTypes);
+				if (mismatch) throw new IosDeviceMismatchError(`${mismatch}. Stim will not silently boot a different model.`);
+				const versionMismatch = flags.runtimeFlag ? runtimeMismatch(sim.runtime, flags.runtimeFlag, listIosRuntimes()) : null;
+				if (versionMismatch) throw new IosDeviceMismatchError(`${versionMismatch}. Stim will not silently boot a different iOS version.`);
+				const model = {
+					model: deviceTypes.find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null,
+					runtime: parseRuntimeVersion(sim.runtime)
+				};
+				const name = await withIosDeviceNameLock(() => renameToOwnedName(sim, label, model, projectPath));
+				const updated = {
+					deviceUdid: sim.udid,
+					owned: true,
+					deviceName: name,
+					...record.simslimManaged ? { simslimManaged: true } : {},
+					...record.adopted ? { adopted: true } : {},
+					...record.adoptionPending ? { adoptionPending: true } : {},
+					...record.parkedCacheKey ? { parkedCacheKey: record.parkedCacheKey } : {},
+					...record.schemeApprovals ? { schemeApprovals: record.schemeApprovals } : {}
+				};
+				const configure = async () => {
+					if (record.adoptionPending) resetAdoptedSim(sim.udid, out);
+					return configureOwnedIosSim({
+						record: updated,
+						projectPath,
+						slot,
+						profile: simslimProfile,
+						out,
+						reconcileIosSimulator
+					});
+				};
+				const facts = {
+					deviceType: model.model,
+					runtime: model.runtime
+				};
+				if (sim.state !== "Booted") {
+					out(chalk.dim(phaseLine("device", `booting ${name} (${sim.udid})`)));
+					return {
+						...updated,
+						booting: startIosBoot(sim.udid, configure, name, out, flags.simulatorApp),
+						...facts
+					};
+				}
+				return {
+					...await configure(),
+					...facts
+				};
+			}
+		} else {
+			const sim = listAllIosSims().find((s) => s.udid === record.deviceUdid);
+			if (sim) {
+				if (sim.state !== "Booted") {
+					note(chalk.yellow(`Note: assigned sim ${sim.name} (${sim.udid}) is shut down and is not owned by Stim, so it will not be booted automatically.`));
+					note(chalk.dim("Boot it yourself, or run `stim gc --delete` to clear the assignment so Stim can create an owned sim."));
+				}
+				return record;
+			}
+		}
+		withConfigLock(() => {
+			const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.ios;
+			if (!current) return;
+			if (current.deviceUdid !== record.deviceUdid || current.owned !== record.owned) throw new Error("The simulator assignment changed during recovery. Run `stim ios` again.");
+			clearDevice(projectPath, "ios", slot);
+		});
+	}
+	const choice = resolveIosCreation({
+		deviceType: flags.deviceType || settings.ios?.deviceType,
+		runtime: flags.runtime || settings.ios?.runtime
+	});
+	const adopted = parkedMaxSetting("ios").max > 0 ? await withIosDeviceNameLock(() => takeParkedIosSim({
+		projectPath,
+		slot,
+		label,
+		choice,
+		out
+	})) : null;
+	if (adopted) {
+		out(chalk.dim(phaseLine("device", `booting ${adopted.deviceName} (${adopted.deviceUdid})`)));
+		const booting = startIosBoot(adopted.deviceUdid, async () => {
+			resetAdoptedSim(adopted.deviceUdid, out);
+			await configureOwnedIosSim({
+				record: adopted,
+				projectPath,
+				slot,
+				profile: simslimProfile,
+				out,
+				reconcileIosSimulator
+			});
+		}, adopted.deviceName, out, flags.simulatorApp);
+		return {
+			...adopted,
+			booting,
+			deviceType: choice.deviceType,
+			runtime: choice.runtime
+		};
+	}
+	const created = await withIosDeviceNameLock(() => {
+		const suffix = ownedIosNameSuffix(label, {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		}, projectPath);
+		const result = createOwnedIosSim(label, { suffix }, choice);
+		setDevice(projectPath, "ios", {
+			deviceUdid: result.udid,
+			owned: true,
+			deviceName: result.name
+		}, slot);
+		return result;
+	});
+	const newRecord = {
+		deviceUdid: created.udid,
+		owned: true,
+		deviceName: created.name
+	};
+	const booting = startIosBoot(created.udid, () => configureOwnedIosSim({
+		record: newRecord,
+		projectPath,
+		slot,
+		profile: simslimProfile,
+		out,
+		reconcileIosSimulator
+	}), created.name, out, flags.simulatorApp);
+	return {
+		...newRecord,
+		created: true,
+		booting,
+		deviceType: created.deviceType,
+		runtime: created.runtime
+	};
+}
+function withIosDeviceNameLock(fn) {
+	return withWorkspaceProcessLock(getConfigDir(), "ios-device-names", async () => fn(), { external: true });
+}
+function ownedIosNameSuffix(label, model, projectPath, udid) {
+	const names = new Set(listAllIosSims({ includeUnavailable: true }).filter((sim) => sim.udid !== udid).map((sim) => sim.name));
+	for (const project of Object.values(loadConfig()?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
+		const record = platforms.ios;
+		if (record?.deviceUdid !== udid && record?.deviceName) names.add(record.deviceName);
+	}
+	for (const parked of readParked("ios")) if (parked.udid !== udid) names.add(parked.name);
+	let suffix = "";
+	for (let attempt = 0; names.has(ownedSimName(label, model, suffix)); attempt++) suffix = ` ${workspaceId(projectPath)}${attempt ? `-${attempt}` : ""}`;
+	return suffix;
+}
+function renameToOwnedName(sim, label, model, projectPath) {
+	const wanted = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, sim.udid));
+	if (sim.name === wanted) return wanted;
+	try {
+		renameIosSim(sim.udid, wanted);
+		return wanted;
+	} catch {
+		return sim.name;
+	}
+}
+function resetAdoptedSim(udid, out) {
+	out(chalk.dim(phaseLine("device", `resetting privacy grants and the keychain on ${udid}`)));
+	resetIosPrivacy(udid);
+	resetIosKeychain(udid);
+}
+function takeParkedIosSim({ projectPath, slot, label, choice, out }) {
+	const candidates = selectParked(readParked("ios"), {
+		deviceTypeIdentifier: choice.deviceTypeId,
+		runtimeIdentifier: choice.runtimeId
+	});
+	if (candidates.length === 0) return null;
+	const listed = new Map(listAllIosSims({ includeUnavailable: true }).map((sim) => [sim.udid, sim]));
+	for (const parked of candidates) {
+		const sim = listed.get(parked.udid);
+		if (!sim || !sim.available) {
+			const result = sim ? teardownParkedIosSim(parked.udid, { label: parked.name }) : null;
+			if (sim ? result?.status === "torn-down" : dropParked("ios", parked.udid)) out(chalk.dim(phaseLine("device", `deleted parked ${parked.name} (${parked.udid}): ${sim ? "unavailable" : "gone"}`)));
+			else if (result?.status === "failed") out(chalk.yellow(phaseLine("device", `could not delete unavailable parked ${parked.name} (${parked.udid}): ${result.reason}`)));
+			continue;
+		}
+		if (!sim.name.startsWith("stim-")) {
+			out(chalk.yellow(phaseLine("device", `kept parked record for ${parked.udid}: simulator is now named ${JSON.stringify(sim.name)} and is not Stim-owned`)));
+			continue;
+		}
+		const model = {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		};
+		const name = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, parked.udid));
+		const device = {
+			deviceUdid: parked.udid,
+			owned: true,
+			deviceName: name,
+			adopted: true,
+			adoptionPending: true,
+			...parked.simslimManaged ? { simslimManaged: true } : {},
+			...parked.cacheKey ? { parkedCacheKey: parked.cacheKey } : {}
+		};
+		const adopted = adoptParked({
+			platform: "ios",
+			projectPath,
+			slot,
+			udid: parked.udid,
+			device
+		});
+		if (!adopted) continue;
+		try {
+			renameIosSim(parked.udid, name);
+		} catch {}
+		return adopted.schemeApprovals && adopted.schemeApprovals.length > 0 ? {
+			...device,
+			schemeApprovals: adopted.schemeApprovals
+		} : device;
+	}
+	return null;
+}
+function clearIosAdoptionPending(projectPath, slot = "default") {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
+		if (!cfg || !ios?.adoptionPending) return;
+		delete ios.adopted;
+		delete ios.adoptionPending;
+		delete ios.parkedCacheKey;
+		saveConfig(cfg);
+	});
+}
+async function configureOwnedIosSim({ record, projectPath, slot, profile, out, reconcileIosSimulator }) {
+	if (profile) out(chalk.dim(phaseLine("device", `applying the SimSlim profile to ${record.deviceUdid}`)));
+	else if (record.simslimManaged) out(chalk.dim(phaseLine("device", `restoring stock simulator services on ${record.deviceUdid}`)));
+	const previouslyManaged = Boolean(record.simslimManaged);
+	if (profile && !record.simslimManaged) {
+		const pending = {
+			...record,
+			simslimManaged: true
+		};
+		setDevice(projectPath, "ios", pending, slot);
+		record = pending;
+	}
+	const result = await reconcileIosSimulator({
+		udid: record.deviceUdid,
+		profile,
+		previouslyManaged,
+		out
+	});
+	const updated = { ...record };
+	if (result.managed) updated.simslimManaged = true;
+	else delete updated.simslimManaged;
+	setDevice(projectPath, "ios", updated, slot);
+	return updated;
+}
+async function ensureIosBooted({ device, simulatorApp, timeoutMs, pollMs, out }) {
+	const udid = device?.deviceUdid;
+	if (!udid) return {
+		failed: true,
+		reason: "No iOS simulator is recorded for this project."
+	};
+	const ready = () => {
+		try {
+			getExecutor().runFile("xcrun", [
+				"simctl",
+				"spawn",
+				udid,
+				"launchctl",
+				"list"
+			], { timeoutMs: 3e4 });
+			return {
+				ok: true,
+				udid
+			};
+		} catch (error) {
+			return {
+				failed: true,
+				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
+			};
+		}
+	};
+	const booting = device?.booting;
+	if (booting?.udid === udid) {
+		try {
+			await booting.done;
+		} catch (e) {
+			return {
+				failed: true,
+				reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+			};
+		}
+		return ready();
+	}
+	let resolved;
+	try {
+		resolved = resolveOwnedIosSim(udid);
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not list simulators: ${e?.message || e}`
+		};
+	}
+	if (resolved.missing) return {
+		failed: true,
+		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
+	};
+	if (resolved.notOwned) return {
+		failed: true,
+		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
+	};
+	const sim = resolved.sim;
+	if (sim.state === "Booted") {
+		const result = ready();
+		if (result.ok && simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
+		return result;
+	}
+	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
+	const bootDeadline = Date.now() + timeoutMs;
+	try {
+		await bootIosSim(udid, {
+			timeoutMs,
+			label: sim.name,
+			out,
+			simulatorApp
+		});
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+		};
+	}
+	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
+	while (Date.now() < deadline) {
+		await sleep(pollMs);
+		let state = null;
+		try {
+			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
+		} catch {}
+		if (state === "Booted") return ready();
+	}
+	return {
+		failed: true,
+		reason: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
+	};
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#endregion
+export { ensureOwnedIosDevice as i, clearIosAdoptionPending as n, ensureIosBooted as r, IosDeviceMismatchError as t };

package/dist/{device-lease-5c3WrVRm.mjs → device-lease-D-hLqx1b.mjs}

@@ -1,15 +1,16 @@
-import { A as ownership_claim_exports, G as validateDeviceSlot, V as parseDeviceSlotKey, d as getConfigDir, z as deviceSlotKey } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { r as register } from "./cache-manifest-C68QQ0ua.mjs";
-import { C as sharedBuildCache, F as withDirLock, b as writeWorkspaceState, h as readWorkspaceState, m as clearWorkspaceStateKeys, v as withWorkspaceStateLock } from "./metro-CcEo8Fl8.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Drw_o-Fb.mjs";
-import { a as formatElapsed, i as formatDuration, m as shortHash } from "./command-output-DVcpw6eE.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { B as parseDeviceSlotKey, R as deviceSlotKey, W as validateDeviceSlot, d as getConfigDir } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as register } from "./cache-manifest-DnUHBJaU.mjs";
+import { a as formatElapsed, i as formatDuration, m as shortHash } from "./command-output-DnJMdEY-.mjs";
+import { c as writeWorkspaceState, d as sharedBuildCache, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState, w as withDirLock$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-D0XfSe8u.mjs";
+import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { join } from "path";
+import { join as join$1 } from "path";
 import { artifactIn, buildCacheKey, resolveArtifact, storeArtifact } from "@stim-cli/core";
-import { join as join$1 } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
 import { isDeepStrictEqual } from "util";
 import * as expoFingerprint from "@expo/fingerprint";
 import { buildUploadTimeoutMs } from "@stim-cli/cache";
@@ -36,7 +37,7 @@ function readAssetManifest(root) {
 			return;
 		}
 		for (const name of names) {
-			const child = join$1(abs, name);
+			const child = join(abs, name);
 			let stat;
 			try {
 				stat = statSync(child);
@@ -108,16 +109,16 @@ function pickGeneratedResDir(names, variant, reactChildren = []) {
 	return null;
 }
 function androidModuleDirs(root, { list = safeList } = {}) {
-	const android = join$1(root, "android");
-	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join$1(android, name, "build", "generated", "res"))).toSorted()];
+	const android = join(root, "android");
+	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join(android, name, "build", "generated", "res"))).toSorted()];
 }
 function findGeneratedResDir(root, variant, { list = safeList } = {}) {
 	for (const module of androidModuleDirs(root, { list })) {
-		const base = join$1(root, "android", module, "build", "generated", "res");
+		const base = join(root, "android", module, "build", "generated", "res");
 		const names = list(base);
 		if (names.length === 0) continue;
-		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join$1(base, "react")) : []);
-		if (picked) return join$1(base, ...picked.split("/"));
+		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join(base, "react")) : []);
+		if (picked) return join(base, ...picked.split("/"));
 	}
 	return null;
 }
@@ -159,7 +160,7 @@ function safeList(dir) {
 //#endregion
 //#region src/cache/build-cache.ts
 function entryDir(platform, key, root = sharedBuildCache()) {
-	return join(root, platform, key);
+	return join$1(root, platform, key);
 }
 const FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
 /**
@@ -211,17 +212,17 @@ function storeBuild(platform, key, buildPath, rootOrOptions = {}) {
 		overwrite: Boolean(options.overwrite),
 		writeMetadata: (staging) => {
 			if (Array.isArray(options.sources)) try {
-				writeFileSync$1(join(staging, SOURCES_FILE), JSON.stringify(options.sources.map(withoutContents)));
+				writeFileSync$1(join$1(staging, SOURCES_FILE), JSON.stringify(options.sources.map(withoutContents)));
 			} catch {}
 			if (options.assetManifest) try {
-				writeFileSync$1(join(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
+				writeFileSync$1(join$1(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
 			} catch {}
 		}
 	});
 }
 const PROVIDER_DOWNLOAD_DIR = "cache-provider";
 function providerDownloadPath(workspacePath) {
-	return join(workspacePath, PROVIDER_DOWNLOAD_DIR);
+	return join$1(workspacePath, PROVIDER_DOWNLOAD_DIR);
 }
 /**
 * Empties and registers the scratch directory a provider downloads into. It is
@@ -283,7 +284,7 @@ function withoutContents(source) {
 }
 function storedSources(platform, key, root = sharedBuildCache()) {
 	try {
-		const parsed = JSON.parse(readFileSync$1(join(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
+		const parsed = JSON.parse(readFileSync$1(join$1(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
 		return Array.isArray(parsed) ? parsed : null;
 	} catch {
 		return null;
@@ -291,7 +292,7 @@ function storedSources(platform, key, root = sharedBuildCache()) {
 }
 function storedAssetManifest(platform, key, root = sharedBuildCache()) {
 	try {
-		return parseAssetManifest(readFileSync$1(join(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
+		return parseAssetManifest(readFileSync$1(join$1(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
 	} catch {
 		return null;
 	}
@@ -485,10 +486,10 @@ function segment(value) {
 	return String(value).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "unknown";
 }
 function buildLocksDir() {
-	return join$1(getConfigDir(), "build-locks");
+	return join(getConfigDir(), "build-locks");
 }
 function buildLockPath(platform, key) {
-	return join$1(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX$1}`);
+	return join(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX$1}`);
 }
 function label(platform) {
 	return `${platform} build`;
@@ -560,7 +561,7 @@ function listBuildLocks() {
 	const locks = [];
 	for (const name of names) {
 		if (!name.endsWith(LOCK_SUFFIX$1)) continue;
-		const path = join$1(dir, name);
+		const path = join(dir, name);
 		try {
 			if (!statSync(path).isDirectory()) continue;
 		} catch {
@@ -652,7 +653,7 @@ async function waitForBuild({ platform, key, resolve = resolveBuild, intervalMs
 		await sleep(intervalMs);
 	}
 }
-async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, command, acquire, wait, now, phase, warn, out }) {
+async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, command, acquire, wait, now, phase, waitingOn, warn, out }) {
 	const waitStarted = now();
 	let failedHolder;
 	let released = null;
@@ -673,6 +674,7 @@ async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, c
 		if (attempt?.acquired) {
 			const previous = attempt.tookOver ?? failedHolder;
 			if (previous) warn(takeoverLine(previous));
+			waitingOn(null);
 			return {
 				refusal: null,
 				lock: attempt,
@@ -680,16 +682,20 @@ async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, c
 				released
 			};
 		}
-		if (!attempt?.held) return {
-			refusal: null,
-			lock: null,
-			hit: null,
-			released
-		};
+		if (!attempt?.held) {
+			waitingOn(null);
+			return {
+				refusal: null,
+				lock: null,
+				hit: null,
+				released
+			};
+		}
 		released = null;
 		const holder = attempt.held;
 		const who = holder.projectRoot || "another workspace";
 		phase(`${who} is already building ${shortHash(fingerprint)} (pid ${holder.pid})${holder.logFile ? ` -- tail ${holder.logFile}` : ""} -- stim guide lifecycle concurrency`);
+		waitingOn(holder.projectRoot || null);
 		let waited;
 		try {
 			const ceilingMs = WAIT_CEILING_MS - (now() - waitStarted);
@@ -715,6 +721,7 @@ async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, c
 			} };
 		}
 		if (waited.hit) {
+			waitingOn(null);
 			phase(`waited ${formatDuration(waited.waitedMs)} for ${who}'s build -> installed from cache -- stim guide lifecycle concurrency`);
 			return {
 				refusal: null,
@@ -750,16 +757,16 @@ const LEASE_SUFFIX = ".json";
 const LOCK_SUFFIX = ".lock";
 const DURATION = /^[1-9][0-9]*(s|m)$/;
 function deviceLocksDir() {
-	return join$1(getConfigDir(), "device-locks");
+	return join(getConfigDir(), "device-locks");
 }
 function leaseStem(platform, id) {
 	return `${segment(platform)}-${segment(id)}`;
 }
 function deviceLeasePath(platform, id) {
-	return join$1(deviceLocksDir(), `${leaseStem(platform, id)}${LEASE_SUFFIX}`);
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LEASE_SUFFIX}`);
 }
 function deviceLeaseLockPath(platform, id) {
-	return join$1(deviceLocksDir(), `${leaseStem(platform, id)}${LOCK_SUFFIX}`);
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LOCK_SUFFIX}`);
 }
 const fileLeaseIo = {
 	withHolderLock: withWorkspaceStateLock,
@@ -793,7 +800,7 @@ const fileLeaseIo = {
 		}
 	},
 	withLeaseLock(lockPath, fn) {
-		return withDirLock(lockPath, fn, { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) });
+		return withDirLock$1(lockPath, fn, { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) });
 	},
 	readHolder(root) {
 		return parseWorkspaceLeases(readWorkspaceState(root)?.deviceLeases);
@@ -878,7 +885,7 @@ function listLeaseFiles(io = fileLeaseIo) {
 	const entries = [];
 	for (const name of io.listLeaseNames().toSorted()) {
 		if (!name.endsWith(LEASE_SUFFIX)) continue;
-		const path = join$1(dir, name);
+		const path = join(dir, name);
 		const lease = parseLease(io.readLease(path));
 		const stem = name.slice(0, -5);
 		const cut = stem.indexOf("-");