stim 1.1.0 → 1.3.0

package/dist/{xcode-CDB6fytw.mjs → xcode-D7sAp-Zy.mjs}

@@ -1,23 +1,24 @@
-import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
-import { C as withConfigLock, _ as releaseAndroidConsolePort, b as setDevice, g as loadConfig, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, y as saveConfig } from "./config-D7uu8Gbq.mjs";
-import { r as register } from "./cache-manifest-oeH18ERr.mjs";
-import { E as workspaceId, S as sharedCompilationCache, w as workspaceDerivedData } from "./state-IYEY-zi8.mjs";
-import { s as ownedDeviceLabel } from "./project-COj6nzzh.mjs";
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { C as withConfigLock, E as inspectProcessIdentity, L as deviceSlotPlatforms, _ as releaseAndroidConsolePort, b as setDevice, g as loadConfig, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, w as captureProcessIdentity, y as saveConfig, z as projectDeviceSlots } from "./config-CcefMY2Q.mjs";
+import { r as register } from "./cache-manifest-CXR-Y8pH.mjs";
+import { E as workspaceId, S as sharedCompilationCache, w as workspaceDerivedData } from "./state-B3XA2wp2.mjs";
+import { s as ownedDeviceLabel } from "./project-fKmuIaMI.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
-import { r as pidExists } from "./metro-B01H3EuD.mjs";
-import { C as selectParked, S as readParked, _ as teardownParkedIosSim, b as dropParked, g as teardownParkedAvd, m as teardownOwnedAvd, x as parkedMaxSetting, y as adoptParked } from "./remote-cache-DOi5-zLj.mjs";
-import { H as resolveOptimizations, l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-BSwrY4FZ.mjs";
+import { r as pidExists } from "./metro-CORqXyTL.mjs";
 import { a as formatElapsed, l as phaseLine } from "./command-output-8wHMEde0.mjs";
-import { _ as resetIosKeychain, b as resolveOwnedIosSim, c as iosRuntimeMatches, g as renameIosSim, h as parseRuntimeVersion, i as createOwnedIosSim, l as listAllIosSims, n as bootIosSim, p as ownedSimName, u as listIosDeviceTypes, v as resetIosPrivacy, y as resolveIosCreation } from "./ios-BZxKPuqP.mjs";
-import { A as resolveOwnedAvdSerial, C as ownedAvdMatchesConfiguration, D as pickDefaultSystemImage, P as waitForBoot, T as ownedAvdSystemImage, _ as listAdbDevices, c as bootAndroidEmulator, g as getAvdNameForSerial, l as configureNewOwnedAvd, o as assertOwnedAvdStopped, s as avdPoolConfiguration, u as createOwnedAvd, v as listAvds, w as ownedAvdName, x as nextConsolePort, y as listInstalledSystemImages } from "./android-xmyGBNy5.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-CxOO9-pf.mjs";
-import { t as cleanLine } from "./server-expo-BEMr_m6p.mjs";
+import { f as releaseClaim, h as tryAcquireClaim, i as claimRemoveCommand, l as markClaimChildPending, n as ClaimRefusedError, p as setClaimChild, u as processGroupAlive } from "./ownership-claim-Bf2CAfw3.mjs";
+import { A as pickDefaultSystemImage, D as ownedAvdName, E as ownedAvdMatchesConfiguration, L as waitForBoot, N as resolveOwnedAvdSerial, O as ownedAvdSystemImage, b as listAvds, c as avdPoolConfiguration, d as configureNewOwnedAvd, f as createOwnedAvd, o as assertOwnedAvdStopped, u as bootAndroidEmulator, v as getAvdNameForSerial, w as nextConsolePort, x as listInstalledSystemImages, y as listAdbDevices } from "./android-BqVIJoG7.mjs";
+import { U as resolveOptimizations, l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-DEJf6_kJ.mjs";
+import { t as cleanLine } from "./server-expo-DizT4OMk.mjs";
+import { c as parkedMaxSetting, i as teardownParkedIosSim, l as readParked, o as adoptParked, r as teardownParkedAvd, s as dropParked, t as teardownOwnedAvd, u as selectParked } from "./teardown-ClFp1Aax.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-3NcQnZ0X.mjs";
+import { E as readHostMemoryPressure, T as hostMemoryPressureAdvice, _ as renameIosSim, b as resolveIosCreation, c as iosRuntimeMatches, d as listIosDeviceTypes, g as parseRuntimeVersion, i as createOwnedIosSim, l as iosSimulatorFailureAdvice, m as ownedSimName, n as bootIosSim, u as listAllIosSims, v as resetIosKeychain, x as resolveOwnedIosSim, y as resetIosPrivacy } from "./ios-Deh5js5V.mjs";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import chalk from "chalk";
 //#region src/engine/simslim.ts
-async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn }) {
+async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
 	if (!profile && !previouslyManaged) return {
 		managed: false,
 		profile: null
@@ -39,25 +40,107 @@ async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out
 	};
 	const stdout = createLineReader(onLine);
 	const stderr = createLineReader(onLine);
+	const root = join(getConfigDir(), "simslim-locks", `${encodeURIComponent(udid.toLowerCase())}.lock`);
+	const label = `SimSlim for ${udid}`;
+	const attempt = tryAcquireClaim({
+		root,
+		mode: "exclusive",
+		label
+	});
+	if (attempt.pending) releaseClaim(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new ClaimRefusedError({
+		root,
+		claimPath: attempt.held?.path ?? root,
+		label,
+		reason: "another SimSlim operation is still using this simulator"
+	});
 	let child;
+	let result;
+	let identity;
+	let cancellation;
+	const stopGroup = () => {
+		if (child?.pid !== void 0 && identity && inspectProcessIdentity(identity) === "same") try {
+			process.kill(-child.pid, "SIGKILL");
+		} catch {}
+	};
+	const cancel = (signal) => {
+		cancellation ??= signal;
+		stopGroup();
+	};
+	const onInterrupt = () => cancel("SIGINT");
+	const onTerminate = () => cancel("SIGTERM");
+	const groupAlive = () => child?.pid !== void 0 && processGroupAlive(child.pid);
+	const settled = () => result !== void 0 && !groupAlive();
+	const waitUntil = async (deadline, cancellable = false) => {
+		while (!settled() && Date.now() < deadline) {
+			if (cancellable && cancellation) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(50, deadline - Date.now())));
+		}
+		return settled();
+	};
+	process.on("SIGINT", onInterrupt);
+	process.on("SIGTERM", onTerminate);
+	process.on("exit", stopGroup);
 	try {
-		child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-	} catch (error) {
-		throw simslimLaunchError(error);
+		markClaimChildPending(claim);
+		try {
+			child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				detached: true
+			});
+		} catch (error) {
+			throw simslimLaunchError(error);
+		}
+		child.stdout?.on("data", (chunk) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk) => stderr.push(chunk));
+		waitForChild(child).then((value) => {
+			result = value;
+		});
+		if (child.pid !== void 0) {
+			const captured = captureProcessIdentity(child.pid);
+			if (captured.ok) {
+				identity = {
+					pid: child.pid,
+					processToken: captured.token
+				};
+				try {
+					setClaimChild(claim, identity);
+				} catch {}
+			}
+		}
+		const completed = await waitUntil(Date.now() + timeoutMs, true);
+		if (cancellation || !completed) {
+			stopGroup();
+			const stopped = await waitUntil(Date.now() + cleanupMs);
+			const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+			const recovery = stopped ? "Its process group has stopped. Retry stim ios to reconcile the retained simulator settings." : `Its process group could not be confirmed stopped. The claim remains at ${claim.path}. Inspect the SimSlim process group ${child.pid ?? "unknown"} before retrying. Only when nothing is using it, remove the claim: ${claimRemoveCommand(claim.path)}`;
+			const message = `SimSlim ${action} ${cancellation ? `interrupted by ${cancellation}` : `exceeded ${Math.round(timeoutMs / 1e3)}s`}. ${recovery}${detail}`;
+			if (cancellation) out(message);
+			throw Object.assign(new Error(message), { code: cancellation ? "EINTR" : "ETIMEDOUT" });
+		}
+	} finally {
+		if (!child || settled()) releaseClaim(claim);
+		else {
+			child.stdout?.destroy?.();
+			child.stderr?.destroy?.();
+			child.unref();
+		}
+		process.off("SIGINT", onInterrupt);
+		process.off("SIGTERM", onTerminate);
+		process.off("exit", stopGroup);
+		if (cancellation) process.exit(cancellation === "SIGINT" ? 130 : 143);
 	}
-	child.stdout?.on("data", (chunk) => stdout.push(chunk));
-	child.stderr?.on("data", (chunk) => stderr.push(chunk));
-	const result = await waitForChild(child);
 	stdout.flush();
 	stderr.flush();
-	if (result.error) throw simslimLaunchError(result.error);
-	if (result.code !== 0) {
+	if (result?.error) throw simslimLaunchError(result.error);
+	if (result?.code !== 0) {
 		const detail = lines.length ? ` ${lines.join(" | ")}` : "";
-		throw new Error(`SimSlim ${action} failed with exit code ${result.code ?? "unknown"}.${detail}`);
+		throw new Error(`SimSlim ${action} failed with exit code ${result?.code ?? "unknown"}.${detail}`);
 	}
 	return {
 		managed: Boolean(profile),
@@ -78,9 +161,12 @@ function simslimIsOnPath() {
 }
 //#endregion
 //#region src/engine/device.ts
-function startIosBoot(udid, configure) {
+function startIosBoot(udid, configure, label, out) {
 	const done = (async () => {
-		await bootIosSim(udid);
+		await bootIosSim(udid, {
+			label,
+			out
+		});
 		await configure();
 	})();
 	done.catch(() => {});
@@ -89,11 +175,13 @@ function startIosBoot(udid, configure) {
 		done
 	};
 }
-async function ensureOwnedDevice({ platform, project, projectPath, settingsRoot = projectPath, label = ownedDeviceLabel(projectPath), settings, flags = {}, note = () => {}, out = () => {}, logFile = null, alive = pidExists, configureAvd = configureNewOwnedAvd, teardownAvd = teardownOwnedAvd, reconcileIosSimulator = reconcileSimSlim }) {
-	const record = project?.platforms?.[platform] ?? null;
+async function ensureOwnedDevice({ platform, project, projectPath, slot, settingsRoot = projectPath, label = ownedDeviceLabel(projectPath), settings, flags = {}, note = () => {}, out = () => {}, logFile = null, alive = pidExists, configureAvd = configureNewOwnedAvd, teardownAvd = teardownOwnedAvd, reconcileIosSimulator = reconcileSimSlim }) {
+	if (slot && slot !== "default") label = `${label}-${slot}`;
+	const record = deviceSlotPlatforms(project, slot)?.[platform] ?? null;
 	if (platform === "ios") return ensureOwnedIosDevice({
 		record,
 		projectPath,
+		slot,
 		settingsRoot,
 		label,
 		settings,
@@ -105,6 +193,7 @@ async function ensureOwnedDevice({ platform, project, projectPath, settingsRoot
 	return ensureOwnedAndroidDevice({
 		record,
 		projectPath,
+		slot,
 		settingsRoot,
 		label,
 		settings,
@@ -117,7 +206,9 @@ async function ensureOwnedDevice({ platform, project, projectPath, settingsRoot
 		teardownAvd
 	});
 }
-async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label, settings, flags, note, out, reconcileIosSimulator }) {
+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) {
@@ -148,6 +239,7 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 					return configureOwnedIosSim({
 						record: updated,
 						projectPath,
+						slot,
 						profile: simslimProfile,
 						out,
 						reconcileIosSimulator
@@ -161,7 +253,7 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 					out(chalk.dim(phaseLine("device", `booting ${name} (${sim.udid})`)));
 					return {
 						...updated,
-						booting: startIosBoot(sim.udid, configure),
+						booting: startIosBoot(sim.udid, configure, name, out),
 						...facts
 					};
 				}
@@ -180,6 +272,12 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 				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,
@@ -187,6 +285,7 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 	});
 	const adopted = parkedMaxSetting("ios").max > 0 ? await withIosDeviceNameLock(() => takeParkedIosSim({
 		projectPath,
+		slot,
 		label,
 		choice,
 		out
@@ -198,11 +297,12 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 			await configureOwnedIosSim({
 				record: adopted,
 				projectPath,
+				slot,
 				profile: simslimProfile,
 				out,
 				reconcileIosSimulator
 			});
-		});
+		}, adopted.deviceName, out);
 		return {
 			...adopted,
 			booting,
@@ -220,7 +320,7 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 			deviceUdid: result.udid,
 			owned: true,
 			deviceName: result.name
-		});
+		}, slot);
 		return result;
 	});
 	const newRecord = {
@@ -231,10 +331,11 @@ async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label,
 	const booting = startIosBoot(created.udid, () => configureOwnedIosSim({
 		record: newRecord,
 		projectPath,
+		slot,
 		profile: simslimProfile,
 		out,
 		reconcileIosSimulator
-	}));
+	}), created.name, out);
 	return {
 		...newRecord,
 		created: true,
@@ -248,8 +349,8 @@ function withIosDeviceNameLock(fn) {
 }
 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 ?? {})) {
-		const record = project.platforms?.ios;
+	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);
@@ -272,7 +373,7 @@ function resetAdoptedSim(udid, out) {
 	resetIosPrivacy(udid);
 	resetIosKeychain(udid);
 }
-function takeParkedIosSim({ projectPath, label, choice, out }) {
+function takeParkedIosSim({ projectPath, slot, label, choice, out }) {
 	const candidates = selectParked(readParked("ios"), {
 		deviceTypeIdentifier: choice.deviceTypeId,
 		runtimeIdentifier: choice.runtimeId
@@ -308,6 +409,7 @@ function takeParkedIosSim({ projectPath, label, choice, out }) {
 		if (!adoptParked({
 			platform: "ios",
 			projectPath,
+			slot,
 			udid: parked.udid,
 			device
 		})) continue;
@@ -318,10 +420,10 @@ function takeParkedIosSim({ projectPath, label, choice, out }) {
 	}
 	return null;
 }
-function clearIosAdoptionPending(projectPath) {
+function clearIosAdoptionPending(projectPath, slot = "default") {
 	withConfigLock(() => {
 		const cfg = loadConfig();
-		const ios = cfg?.projects?.[projectPath]?.platforms?.ios;
+		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
 		if (!cfg || !ios?.adoptionPending) return;
 		delete ios.adopted;
 		delete ios.adoptionPending;
@@ -329,7 +431,7 @@ function clearIosAdoptionPending(projectPath) {
 		saveConfig(cfg);
 	});
 }
-async function configureOwnedIosSim({ record, projectPath, profile, out, reconcileIosSimulator }) {
+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);
@@ -338,7 +440,7 @@ async function configureOwnedIosSim({ record, projectPath, profile, out, reconci
 			...record,
 			simslimManaged: true
 		};
-		setDevice(projectPath, "ios", pending);
+		setDevice(projectPath, "ios", pending, slot);
 		record = pending;
 	}
 	const result = await reconcileIosSimulator({
@@ -350,24 +452,31 @@ async function configureOwnedIosSim({ record, projectPath, profile, out, reconci
 	const updated = { ...record };
 	if (result.managed) updated.simslimManaged = true;
 	else delete updated.simslimManaged;
-	setDevice(projectPath, "ios", updated);
+	setDevice(projectPath, "ios", updated, slot);
 	return updated;
 }
-function findOtherProjectOwningAvd(avdName, projectPath) {
+function findOtherProjectOwningAvd(avdName, projectPath, selectedSlot = "default") {
 	const cfg = loadConfig();
-	for (const [path, proj] of Object.entries(cfg?.projects || {})) {
-		if (path === projectPath) continue;
-		if (proj?.platforms?.android?.avdName === avdName) return path;
-	}
+	for (const [path, proj] of Object.entries(cfg?.projects || {})) if (projectDeviceSlots(proj).some(({ slot, platforms }) => (path !== projectPath || slot !== selectedSlot) && platforms.android?.avdName?.toLowerCase() === avdName.toLowerCase())) return path;
 	return null;
 }
-async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, label, settings, flags, note, out, logFile, alive, configureAvd, teardownAvd }) {
+var AvdRecoveryError = class extends Error {
+	remedy;
+	constructor(message, remedy, cause) {
+		super(message, { cause });
+		this.remedy = remedy;
+	}
+};
+async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, logFile, alive, configureAvd, teardownAvd }) {
 	const avdConfig = androidAvdConfigSetting(settings, settingsRoot);
 	const configuration = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), avdConfig);
 	if (record?.setupIncomplete && record.avdName) {
-		const cleanup = teardownAvd(record.avdName, { del: true });
+		const cleanup = teardownAvd(record.avdName, {
+			del: true,
+			owner: { projectPath }
+		});
 		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new Error(`Owned AVD ${record.avdName} has incomplete setup and could not be deleted (${cleanup.reason || cleanup.status}). Fix the cause, then retry; Stim kept the device record for cleanup.`);
-		clearDevice(projectPath, "android");
+		clearDevice(projectPath, "android", slot);
 		record = null;
 	}
 	if (record?.avdName) {
@@ -376,6 +485,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 			if (resolved.notOwned) note(chalk.yellow(`Note: recorded AVD ${record.avdName} is not Stim-owned by name -- creating a fresh owned AVD instead of reusing it.`));
 			else if (resolved.serial) {
 				const consolePort = Number(resolved.serial.replace(/^emulator-/, ""));
+				if (record.consolePort && record.consolePort !== consolePort) out(phaseLine("device", `${record.avdName} changed serial (emulator-${record.consolePort} -> ${resolved.serial}); reconnecting this run, reopen agent-device on ${resolved.serial}`));
 				const updated = {
 					...record,
 					avdName: record.avdName,
@@ -383,7 +493,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 					owned: true,
 					deviceName: record.deviceName ?? record.avdName
 				};
-				setDevice(projectPath, "android", updated);
+				setDevice(projectPath, "android", updated, slot);
 				return {
 					...updated,
 					systemImage: ownedAvdSystemImage(record.avdName)
@@ -395,6 +505,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 						avdName: record.avdName,
 						metadata: record,
 						projectPath,
+						slot,
 						deviceName: record.deviceName,
 						out,
 						logFile,
@@ -421,7 +532,8 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 			if (parked.deletionClaim !== void 0) continue;
 			const resolved = resolveOwnedAvdSerial(parked.name);
 			if (resolved.missing) {
-				dropParked("android", parked.udid);
+				const result = teardownParkedAvd(parked.name);
+				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
 				continue;
 			}
 			if (resolved.notOwned || resolved.serial) continue;
@@ -446,6 +558,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 			if (!adoptParked({
 				platform: "android",
 				projectPath,
+				slot,
 				udid: parked.udid,
 				device: adopted
 			})) continue;
@@ -453,6 +566,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 				...await bootOwnedAvdOnFreshPort({
 					avdName: parked.name,
 					projectPath,
+					slot,
 					metadata: adopted,
 					out,
 					logFile,
@@ -467,9 +581,9 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 	let fresh = false;
 	try {
 		created = withConfigLock(() => {
-			const current = loadConfig()?.projects?.[projectPath]?.platforms?.android;
+			const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.android;
 			if (current?.avdName && current.avdName !== record?.avdName) throw new Error(`Another Stim run assigned AVD ${current.avdName} to this workspace. Retry to use it.`);
-			if (readParked("android").some((entry) => entry.name === ownedAvdName(label)) || findOtherProjectOwningAvd(ownedAvdName(label), projectPath)) label = `${label}-${randomUUID().slice(0, 8)}`;
+			if (readParked("android").some((entry) => entry.name === ownedAvdName(label)) || findOtherProjectOwningAvd(ownedAvdName(label), projectPath, slot)) label = `${label}-${randomUUID().slice(0, 8)}`;
 			const result = createOwnedAvd(label, { systemImage: flags.systemImage || settings.android?.systemImage });
 			setDevice(projectPath, "android", {
 				avdName: result.avdName,
@@ -477,35 +591,52 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 				deviceName: result.avdName,
 				setupIncomplete: true,
 				poolConfiguration: configuration
-			});
+			}, slot);
 			return result;
 		});
 		fresh = true;
 	} catch (e) {
 		const message = String(e?.message || e);
 		const avdName = ownedAvdName(label);
-		if (message.includes("already exists") && listAvds().includes(avdName)) {
-			created = withConfigLock(() => {
-				if (readParked("android").some((entry) => entry.name === avdName)) throw new Error(`AVD ${avdName} was parked by another Stim run. Retry to adopt it safely.`, { cause: e });
-				const owner = findOtherProjectOwningAvd(avdName, projectPath);
-				if (owner) throw new Error(`AVD ${avdName} already exists and is owned by another project (${owner}). Retry to allocate a distinct owned emulator.`, { cause: e });
-				const current = loadConfig()?.projects?.[projectPath]?.platforms?.android;
-				if (current?.avdName) {
-					const state = current.setupIncomplete ? "has incomplete setup" : "was registered";
-					throw new Error(`AVD ${current.avdName} ${state} by another concurrent Stim run. Retry after that run finishes so the recorded device is resolved safely.`, { cause: e });
-				}
-				const result = {
-					avdName,
-					systemImage: ownedAvdSystemImage(avdName)
-				};
-				setDevice(projectPath, "android", {
-					avdName,
-					owned: true,
-					deviceName: avdName
+		if (message.includes("already exists")) {
+			try {
+				if (!listAvds().includes(avdName)) throw new AvdRecoveryError(`AVD ${avdName} already exists on disk but is not listed by the emulator. ${message}`, "Run `npx stim gc` to inspect orphaned owned AVDs, then `npx stim gc --delete` to reclaim those safe to delete. Retry `stim android` after cleanup; keep any AVD that GC cannot verify.", e);
+				created = withConfigLock(() => {
+					if (readParked("android").some((entry) => entry.name === avdName)) throw new Error(`AVD ${avdName} was parked by another Stim run. Retry to adopt it safely.`, { cause: e });
+					const owner = findOtherProjectOwningAvd(avdName, projectPath, slot);
+					if (owner) throw new Error(`AVD ${avdName} already exists and is owned by another project (${owner}). Retry to allocate a distinct owned emulator.`, { cause: e });
+					const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.android;
+					if (current?.avdName) {
+						const state = current.setupIncomplete ? "has incomplete setup" : "was registered";
+						throw new Error(`AVD ${current.avdName} ${state} by another concurrent Stim run. Retry after that run finishes so the recorded device is resolved safely.`, { cause: e });
+					}
+					const resolved = resolveOwnedAvdSerial(avdName);
+					if (resolved.missing || resolved.notOwned) throw new Error(`AVD ${avdName} could not be verified for recovery. Retry after checking its registration.`, { cause: e });
+					if (!resolved.serial) assertOwnedAvdStopped(avdName);
+					const recovered = {
+						avdName,
+						owned: true,
+						deviceName: avdName,
+						...resolved.serial ? { consolePort: Number(resolved.serial.replace(/^emulator-/, "")) } : {}
+					};
+					setDevice(projectPath, "android", recovered, slot);
+					return {
+						...recovered,
+						systemImage: ownedAvdSystemImage(avdName),
+						serial: resolved.serial
+					};
 				});
-				return result;
-			});
+			} catch (error) {
+				if (error instanceof AvdRecoveryError) throw error;
+				throw new AvdRecoveryError(`Could not recover owned AVD ${avdName}: ${String(error?.message || error)}`, "Inspect `npx stim status` and `adb devices`. Wait for any other Stim run using this AVD to finish, then retry `stim android`. Keep the AVD and its process locks while its state is unverified.", error);
+			}
 			out(chalk.dim(phaseLine("device", `recovered ${avdName} (unrecorded from a prior run)`)));
+			if (created.serial) return {
+				...created,
+				owned: true,
+				deviceName: avdName,
+				created: false
+			};
 		} else throw e;
 	}
 	if (fresh) try {
@@ -514,9 +645,12 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 			avdConfig
 		});
 	} catch (error) {
-		const cleanup = teardownAvd(created.avdName, { del: true });
+		const cleanup = teardownAvd(created.avdName, {
+			del: true,
+			owner: { projectPath }
+		});
 		const kept = cleanup.status === "failed" || cleanup.status === "skipped";
-		if (!kept) clearDevice(projectPath, "android");
+		if (!kept) clearDevice(projectPath, "android", slot);
 		const orphan = kept ? ` The owned AVD remains tracked for cleanup (${cleanup.reason || cleanup.status}); fix the cause, then retry or run \`stim gc --delete\`.` : "";
 		throw new Error(`Created owned AVD ${created.avdName}, but could not configure its AVD settings: ${String(error?.message || error)}${orphan}`, { cause: error });
 	}
@@ -525,16 +659,17 @@ async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, lab
 			avdName: created.avdName,
 			metadata: fresh ? { poolConfiguration: configuration } : void 0,
 			projectPath,
+			slot,
 			deviceName: created.avdName,
 			out,
 			logFile,
 			alive
 		}),
-		created: true,
+		created: fresh,
 		systemImage: created.systemImage
 	};
 }
-function claimAndroidConsolePort({ projectPath, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
+function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
 	return lock(() => {
 		const consolePort = nextConsolePort([...recordedPorts(), ...livePorts]);
 		const claim = {
@@ -545,7 +680,7 @@ function claimAndroidConsolePort({ projectPath, avdName, deviceName, livePorts =
 			owned: true,
 			deviceName: deviceName ?? avdName
 		};
-		record(projectPath, "android", claim);
+		record(projectPath, "android", claim, slot);
 		return claim;
 	});
 }
@@ -553,9 +688,10 @@ function liveAndroidConsolePorts() {
 	const adbLive = listAdbDevices();
 	return [...adbLive.emulators.map((e) => e.consolePort), ...adbLive.unhealthy.map((u) => u.consolePort).filter((p) => p != null)];
 }
-async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, deviceName, out, logFile = null, alive = pidExists }) {
+async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, slot, deviceName, out, logFile = null, alive = pidExists }) {
 	const claim = claimAndroidConsolePort({
 		projectPath,
+		slot,
 		avdName,
 		deviceName,
 		livePorts: liveAndroidConsolePorts(),
@@ -574,7 +710,7 @@ async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, deviceN
 			serial
 		};
 	} catch (error) {
-		releaseAndroidConsolePort(projectPath, claim.consolePort);
+		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
 		throw error;
 	}
 }
@@ -589,25 +725,26 @@ function liveOwnedDeviceCount({ sims = [], adbEmulators = [], config = null } =
 	let count = 0;
 	for (const sim of sims) if (sim?.state === "Booted" && sim.name?.startsWith("stim-")) count++;
 	const livePorts = new Set(adbEmulators.map((e) => e.consolePort));
-	for (const proj of Object.values(config?.projects || {})) {
-		const android = proj?.platforms?.android;
+	for (const proj of Object.values(config?.projects || {})) for (const { platforms } of projectDeviceSlots(proj)) {
+		const android = platforms.android;
 		if (android?.owned && android.avdName && typeof android.consolePort === "number" && livePorts.has(android.consolePort)) count++;
 	}
 	return count;
 }
-function workspaceHasLiveDevice({ platform, project, sims = [], adbEmulators = [] } = {}) {
+function workspaceHasLiveDevice({ platform, project, slot = "default", sims = [], adbEmulators = [] } = {}) {
 	if (!platform) return false;
-	const record = project?.platforms?.[platform];
+	const record = deviceSlotPlatforms(project, slot)?.[platform];
 	if (!record) return false;
 	if (platform === "ios") return sims.some((s) => s.udid === record.deviceUdid && s.state === "Booted");
 	return typeof record.consolePort === "number" && adbEmulators.some((e) => e.consolePort === record.consolePort);
 }
-function deviceCapacityRefusal({ platform, project, max, sims = [], adb = null, config = null } = {}) {
+function deviceCapacityRefusal({ platform, project, slot = "default", max, sims = [], adb = null, config = null } = {}) {
 	if (!max || max <= 0) return null;
 	const adbEmulators = adb?.emulators || [];
 	if (workspaceHasLiveDevice({
 		platform,
 		project,
+		slot,
 		sims,
 		adbEmulators
 	})) return null;
@@ -623,7 +760,7 @@ function deviceCapacityRefusal({ platform, project, max, sims = [], adb = null,
 		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
 	};
 }
-function checkDeviceCapacity({ platform, project, max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
+function checkDeviceCapacity({ platform, project, slot = "default", max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
 	if (!max || max <= 0) return null;
 	let simList = [];
 	let adbRes = {
@@ -644,6 +781,7 @@ function checkDeviceCapacity({ platform, project, max, sims = listAllIosSims, ad
 	return deviceCapacityRefusal({
 		platform,
 		project,
+		slot,
 		max,
 		sims: simList,
 		adb: adbRes,
@@ -716,6 +854,26 @@ async function ensureIosBooted({ device, timeoutMs, pollMs, out }) {
 		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 {
@@ -726,10 +884,7 @@ async function ensureIosBooted({ device, timeoutMs, pollMs, out }) {
 				reason: `Could not boot simulator ${udid}: ${e?.message || e}`
 			};
 		}
-		return {
-			ok: true,
-			udid
-		};
+		return ready();
 	}
 	let resolved;
 	try {
@@ -749,14 +904,15 @@ async function ensureIosBooted({ device, timeoutMs, pollMs, out }) {
 		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") return {
-		ok: true,
-		udid
-	};
+	if (sim.state === "Booted") return ready();
 	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
 	const bootDeadline = Date.now() + timeoutMs;
 	try {
-		await bootIosSim(udid, { timeoutMs });
+		await bootIosSim(udid, {
+			timeoutMs,
+			label: sim.name,
+			out
+		});
 	} catch (e) {
 		return {
 			failed: true,
@@ -770,10 +926,7 @@ async function ensureIosBooted({ device, timeoutMs, pollMs, out }) {
 		try {
 			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
 		} catch {}
-		if (state === "Booted") return {
-			ok: true,
-			udid
-		};
+		if (state === "Booted") return ready();
 	}
 	return {
 		failed: true,
@@ -1702,4 +1855,4 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 	};
 }
 //#endregion
-export { unknownIosDeviceTypeRefusal as C, unknownAndroidSystemImageRefusal as S, simslimIsOnPath as T, checkDeviceCapacity as _, ccacheEnabled as a, ensureOwnedDevice as b, discoverXcodeProject as c, resolveScheme as d, startBuildHeartbeat as f, podInstallCommand as g, bundlerPin as h, buildIos as i, readBundleExecutable as l, describeDiagnostic as m, COMPILATION_CACHE_UNAVAILABLE as n, compilationCacheActivityLine as o, tailLines as p, HEARTBEAT_INTERVAL_MS as r, detectXcodeMajor as s, COMPILATION_CACHE_NOT_RUN as t, readBundleId as u, clearIosAdoptionPending as v, unknownIosRuntimeRefusal as w, liveOwnedDeviceCount as x, ensureBooted as y };
+export { unknownAndroidSystemImageRefusal as C, simslimIsOnPath as E, liveOwnedDeviceCount as S, unknownIosRuntimeRefusal as T, AvdRecoveryError as _, ccacheEnabled as a, ensureBooted as b, discoverXcodeProject as c, resolveScheme as d, startBuildHeartbeat as f, podInstallCommand as g, bundlerPin as h, buildIos as i, readBundleExecutable as l, describeDiagnostic as m, COMPILATION_CACHE_UNAVAILABLE as n, compilationCacheActivityLine as o, tailLines as p, HEARTBEAT_INTERVAL_MS as r, detectXcodeMajor as s, COMPILATION_CACHE_NOT_RUN as t, readBundleId as u, checkDeviceCapacity as v, unknownIosDeviceTypeRefusal as w, ensureOwnedDevice as x, clearIosAdoptionPending as y };