stim 1.16.0 → 1.17.1

package/dist/{build-plan-DjeSb2Xl.mjs → build-plan-BJSXzsCL.mjs}

@@ -1,28 +1,34 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { D as withConfigLock$1, H as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, b as releaseAndroidConsolePort, i as clearAndroidBootPending, k as acquireAvdClaim, t as allConsolePortsAndSerials, w as setDevice, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { D as withConfigLock$1, H as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, b as releaseAndroidConsolePort, i as clearAndroidBootPending, k as acquireAvdClaim, p as getProject, t as allConsolePortsAndSerials, w as setDevice, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
 import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-DnJMdEY-.mjs";
-import { Tt as removeTemporaryEntry, at as gitCommonDirOnDisk, l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, wt as makeTemporaryDirectory } from "./settings-oTSkkNrM.mjs";
-import { l as ownedDeviceLabel } from "./project-Du91Ilvc.mjs";
-import { o as pidExists } from "./metro-BeK1ZPz1.mjs";
-import { d as sharedBuildCache } from "./workspace-state-B8-aJ1_5.mjs";
-import { C as diffFingerprintSources, I as storedSources, w as entryDir, y as artifactIn } from "./device-lease-D-hLqx1b.mjs";
-import { b as readStats$1, p as estimateBuild } from "./idle-DYVymG92.mjs";
-import { A as listAvds, B as ownedAvdSystemImage, E as getAvdNameForSerial, F as ownedAvdDeviceProfile, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, O as listAdbDevices, P as nextConsolePort, R as ownedAvdName, W as pickDefaultSystemImage, b as createOwnedAvd, f as assertOwnedAvdStopped, ft as parkedMaxSetting, g as avdPoolConfiguration, j as listInstalledSystemImages, n as OWNED_AVD_CONFIG_DEFAULTS, pt as readParked, st as adoptParked, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, ut as isLegacyDeletionClaim, v as bootAndroidEmulator, y as configureNewOwnedAvd } from "./android-B_NumVyQ.mjs";
-import { j as readHostMemoryPressure, u as listAllIosSims } from "./ios-BaInn3sW.mjs";
-import { i as teardownOwnedAvd, s as teardownParkedAvd } from "./teardown-CL6vDs2Y.mjs";
-import { b as tailLines, u as HEARTBEAT_INTERVAL_MS, y as startBuildHeartbeat } from "./toolchain-DkUflduf.mjs";
-import { t as cleanLine } from "./server-expo-MC0rHlOC.mjs";
-import { t as clearDeviceIdleShutdown } from "./idle-shutdown-CTsDnAde.mjs";
-import { i as liveOwnedDeviceCount } from "./device-capacity-BHwxNBlu.mjs";
-import { i as staleNativeDirRefusal } from "./prebuild-D2fsca_Z.mjs";
-import { i as ensureOwnedIosDevice, r as ensureIosBooted } from "./device-ios-BadmeL2V.mjs";
-import { a as easAuthNote } from "./remote-cache-C8-V13XN.mjs";
-import { t as reconcileSimSlim } from "./simslim-B8-7AoTI.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-CDAIFD-8.mjs";
+import { Tt as removeTemporaryEntry, a as androidAvdConfigSetting, at as gitCommonDirOnDisk, c as androidDataPartitionSizeGbSetting, wt as makeTemporaryDirectory } from "./settings-Cfd-0r2d.mjs";
+import { u as ownedDeviceLabel } from "./project-D47Rh0ly.mjs";
+import { o as pidExists } from "./metro-g8NqiJp-.mjs";
+import { d as sharedBuildCache } from "./workspace-state-DqcCbpE7.mjs";
+import { o as peekBudget } from "./budget-CUDz870h.mjs";
+import { C as diffFingerprintSources, I as storedSources, w as entryDir, y as artifactIn } from "./device-lease-DpoS36_u.mjs";
+import { A as listAvds, B as ownedAvdSystemImage, E as getAvdNameForSerial, F as ownedAvdDeviceProfile, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, O as listAdbDevices, P as nextConsolePort, R as ownedAvdName, W as pickDefaultSystemImage, b as createOwnedAvd, f as assertOwnedAvdStopped, ft as parkedMaxSetting, g as avdPoolConfiguration, j as listInstalledSystemImages, n as OWNED_AVD_CONFIG_DEFAULTS, pt as readParked, st as adoptParked, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, ut as isLegacyDeletionClaim, v as bootAndroidEmulator, y as configureNewOwnedAvd } from "./android-B_YNZy61.mjs";
+import { j as readHostMemoryPressure, u as listAllIosSims } from "./ios-DSfnPfse.mjs";
+import { _ as teardownParkedAvd, m as teardownOwnedAvd } from "./ownership-BMLqyBgJ.mjs";
+import { o as estimateBuild, p as readStats$1 } from "./build-progress-D0WkjCPd.mjs";
+import { b as tailLines, u as HEARTBEAT_INTERVAL_MS, y as startBuildHeartbeat } from "./toolchain-CdrxgUeA.mjs";
+import { t as cleanLine } from "./server-expo-CHTyXD0G.mjs";
+import { f as namedBuildMachine, m as resolveBuildMachine, v as hostingMachines } from "./client-CxNotugx.mjs";
+import { a as call, o as connectHost } from "./hosted-client-CdSoH-G6.mjs";
+import { t as clearDeviceIdleShutdown } from "./idle-shutdown-IGyNV8Cr.mjs";
+import { i as countLiveOwnedDevices, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission, s as peekDeviceSlots } from "./device-capacity-ZC4XSZ4R.mjs";
+import { i as staleNativeDirRefusal } from "./prebuild-D7RUMkwN.mjs";
+import { i as ensureOwnedIosDevice, r as ensureIosBooted } from "./device-ios-C2Um-XUR.mjs";
+import { r as readHostedNative, s as writeHostedNative } from "./ios-state-8L3lgum6.mjs";
+import { n as prepareHostedNative } from "./hosted-native-CZLOrMrN.mjs";
+import { a as easAuthNote } from "./remote-cache-Ci4DQYYj.mjs";
+import { t as reconcileSimSlim } from "./simslim-BWNrc3M3.mjs";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
-import { LAST_BUILD_KEYS, loadConfig, readWorkspaceState } from "@stim-cli/core/state";
+import { LAST_BUILD_KEYS, isJsonObject, loadConfig, machineCapacity, parseHostedChoice, parseHostedNativeOffer, readWorkspaceState } from "@stim-cli/core/state";
 import { claimRemoveCommand, clearClaimChild, markClaimChildPending, processGroupAlive, releaseClaim, setClaimChild } from "@stim-cli/core/ownership-claim";
 import { captureProcessIdentity } from "@stim-cli/core/process-identity";
 import chalk from "chalk";
@@ -30,6 +36,219 @@ import { isDeepStrictEqual } from "node:util";
 import * as expoFingerprint from "@expo/fingerprint";
 import { resolveTieredBuild } from "@stim-cli/cache";
 import { request } from "node:http";
+//#region src/device-host/placement.ts
+function local$1(reason, skipped = []) {
+	return {
+		kind: "local",
+		reason,
+		skipped
+	};
+}
+function decideDevicePlacement(inputs) {
+	if ("sticky" in inputs) {
+		if ("machine" in inputs.sticky) {
+			const reason = `recorded session on ${inputs.sticky.machine}`;
+			return {
+				kind: "host",
+				reason,
+				machines: [{
+					machine: inputs.sticky.machine,
+					reason
+				}],
+				skipped: []
+			};
+		}
+		return {
+			kind: "local",
+			reason: "this workspace's device runs here",
+			skipped: []
+		};
+	}
+	const { platform, here, offers, buildMachine, noWait } = inputs;
+	const { count, max, queued } = here.devices;
+	const cannotTake = !(max === 0 || count !== null && count < max) || queued > 0;
+	const usage = max > 0 ? `${count} of ${max} devices in use` : `${count} devices in use, no device cap`;
+	const localReason = count === null ? "cannot tell how many devices run here; local boot admission decides" : cannotTake ? `${usage}${queued ? `, ${queued} runs queued ahead` : ""}` : here.budgetRefusal ?? (here.memoryPressure !== "normal" ? `host memory pressure ${here.memoryPressure ?? "unknown"} here` : `load ${here.loadPerCore.toFixed(1)}/core here, ${usage}`);
+	if (!offers.length) return local$1("no remote Macs configured; " + localReason);
+	if (count === null) return local$1(localReason);
+	if (!cannotTake && here.memoryPressure === "normal" && !here.budgetRefusal && here.loadPerCore < here.maxLoadPerCore) return local$1(localReason);
+	const skipped = [];
+	const admitted = [];
+	offers.forEach((probe, index) => {
+		let reason = null;
+		if ("failure" in probe) reason = probe.failure;
+		else {
+			const { offer } = probe;
+			if (offer.declined !== null) reason = `declined: ${offer.declined}`;
+			else if (offer.platform !== platform || !offer.choice) reason = `no matching ${platform} device choice`;
+			else if (offer.resources.memoryPressure !== "normal") reason = "host memory pressure unknown or elevated";
+			else if (offer.capacity.available === 0) reason = "no hosted device capacity available";
+			else if (!cannotTake && (offer.resources.loadPerCore === null || offer.resources.loadPerCore >= here.loadPerCore)) reason = offer.resources.loadPerCore === null ? "host load unknown while this Mac has room" : "host is not less loaded than this Mac";
+			else admitted.push({
+				machine: probe.machine,
+				offer,
+				index
+			});
+		}
+		if (reason) skipped.push({
+			machine: probe.machine,
+			reason
+		});
+	});
+	admitted.sort((a, b) => Number(b.machine === buildMachine) - Number(a.machine === buildMachine) || (a.offer.resources.loadPerCore ?? Infinity) - (b.offer.resources.loadPerCore ?? Infinity) || b.offer.resources.memoryFreeBytes - a.offer.resources.memoryFreeBytes || a.index - b.index);
+	if (!admitted.length) return local$1(`${localReason}; no host admits${cannotTake && !noWait ? "; waiting locally if needed" : ""}`, skipped);
+	const machines = admitted.map(({ machine, offer }) => ({
+		machine,
+		reason: `${localReason}; ${machine}${machine === buildMachine ? " is the explicit remote Mac," : ""} load ${offer.resources.loadPerCore === null ? "unknown" : offer.resources.loadPerCore.toFixed(1) + "/core"}`
+	}));
+	return {
+		kind: "host",
+		machines,
+		reason: machines[0].reason,
+		skipped
+	};
+}
+//#endregion
+//#region src/device-host/auto-placement.ts
+async function probeHost(machine, platform, selectors) {
+	let host;
+	const deadline = Date.now() + 3e3;
+	try {
+		host = await connectHost(machine, 3e3, true);
+		const offer = await call(host, "device-host.offer", {
+			platform,
+			...selectors
+		}, Math.max(1, deadline - Date.now()));
+		const resources = isJsonObject(offer.resources) ? offer.resources : {};
+		const parsed = parseHostedNativeOffer({
+			...offer,
+			resources: {
+				...resources,
+				loadPerCore: resources.loadPerCore ?? 0
+			}
+		});
+		let choice = platform === "ios" ? offer.platform === "ios" ? parseHostedChoice(offer.choice) : null : parsed?.platform === "android" ? parsed.choice : null;
+		if (choice && ("runtime" in choice ? selectors.deviceType && selectors.deviceType !== choice.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== choice.runtime.replace(/^iOS /, "") : selectors.systemImage && selectors.systemImage !== choice.systemImage || selectors.deviceProfile && selectors.deviceProfile !== choice.deviceProfile)) choice = null;
+		if (!isJsonObject(offer.capacity) || offer.declined !== null && typeof offer.declined !== "string") throw new Error("unreadable device offer");
+		return {
+			probe: {
+				machine,
+				offer: {
+					platform,
+					choice,
+					declined: offer.declined,
+					capacity: { available: typeof offer.capacity.available === "number" ? offer.capacity.available : null },
+					resources: {
+						loadPerCore: typeof resources.loadPerCore === "number" && Number.isFinite(resources.loadPerCore) && resources.loadPerCore >= 0 ? resources.loadPerCore : null,
+						memoryFreeBytes: typeof resources.memoryFreeBytes === "number" ? resources.memoryFreeBytes : 0,
+						memoryPressure: typeof resources.memoryPressure === "string" ? resources.memoryPressure : null
+					}
+				}
+			},
+			...choice ? { target: {
+				host,
+				choice,
+				session: null
+			} } : {}
+		};
+	} catch (error) {
+		return { probe: {
+			machine,
+			failure: error instanceof Error ? error.message : String(error)
+		} };
+	} finally {
+		host?.connection.close();
+	}
+}
+function hosted(target, reason, skipped = []) {
+	target.selection = {
+		selected: "auto",
+		reason
+	};
+	return {
+		target,
+		placement: {
+			decision: "hosted",
+			machine: target.host.machine,
+			reason
+		},
+		skipped
+	};
+}
+function local(reason, skipped = []) {
+	return {
+		target: null,
+		placement: {
+			decision: "local",
+			reason
+		},
+		skipped
+	};
+}
+async function automaticDevicePlacement({ root, slot, platform, selectors, buildMachine, noWait }, { machines = hostingMachines, read = readHostedNative, write = writeHostedNative, resume = prepareHostedNative, peek = () => peekDeviceSlots({
+	platform,
+	project: getProject(root),
+	slot
+}), capacity = machineCapacity, memory = readHostMemoryPressure, probe = probeHost, budget = peekBudget } = {}) {
+	const recorded = read(root, platform, slot)[slot];
+	if (recorded) {
+		const target = await resume(recorded.machine, selectors, recorded, platform, true);
+		if (target) return {
+			target,
+			placement: {
+				decision: "hosted",
+				machine: recorded.machine,
+				reason: recorded.reason ?? decideDevicePlacement({ sticky: { machine: recorded.machine } }).reason
+			},
+			skipped: [],
+			sticky: true
+		};
+		write(root, slot, null, platform);
+	}
+	const devices = peek();
+	if (devices.localLive) return {
+		...local(decideDevicePlacement({ sticky: { local: true } }).reason),
+		sticky: true
+	};
+	const entries = machines();
+	if (entries === null) throw Object.assign(/* @__PURE__ */ new Error("remote.machines is invalid. Run stim guide settings and correct it."), { code: "STIM_HOSTING_REFUSED" });
+	const preference = resolveBuildMachine(buildMachine, process.env.STIM_REMOTE_BUILD, loadConfig$1()?.remote?.build);
+	buildMachine = namedBuildMachine(preference) ? preference : void 0;
+	const load = capacity();
+	const here = {
+		loadPerCore: load.loadPerCore,
+		maxLoadPerCore: load.maxLoadPerCore,
+		memoryPressure: memory(),
+		devices,
+		budgetRefusal: await budget(root)
+	};
+	const early = decideDevicePlacement({
+		platform,
+		here,
+		offers: entries.map((machine) => ({
+			machine,
+			failure: "not probed"
+		})),
+		buildMachine,
+		noWait
+	});
+	if (early.kind === "local" && early.skipped.length === 0) return local(early.reason);
+	const probes = await Promise.all(entries.map((machine) => probe(machine, platform, selectors)));
+	const decision = decideDevicePlacement({
+		platform,
+		here,
+		offers: probes.map((each) => each.probe),
+		buildMachine,
+		noWait
+	});
+	if (decision.kind === "local") return local(decision.reason, decision.skipped);
+	const target = probes.find((each) => each.probe.machine === decision.machines[0].machine).target;
+	return hosted(target, decision.reason, decision.skipped);
+}
+function devicePlacementLine(placement, skipped) {
+	return `${placement.machine ?? "local"}, ${placement.reason}${placement.decision !== "hosted" && skipped.length ? "; " + skipped.map((each) => `${each.machine}: ${each.reason}`).join("; ") : ""}`;
+}
+//#endregion
 //#region src/engine/metro-warmup.ts
 const WARMUP_TIMEOUT_MS = 6e4;
 async function requestLocal(url, platform, prefetch) {
@@ -325,6 +544,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 				out(chalk.dim(`Recorded port for owned AVD ${record.avdName} is not currently ours; booting it on a freshly allocated port...`));
 				return {
 					...await bootOwnedAvdOnFreshPort({
+						deviceSlotWait: flags.deviceSlotWait,
 						avdName: record.avdName,
 						metadata: record,
 						projectPath,
@@ -397,6 +617,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 			}
 			return {
 				...await bootOwnedAvdOnFreshPort({
+					deviceSlotWait: flags.deviceSlotWait,
 					avdName: parked.name,
 					projectPath,
 					slot,
@@ -435,6 +656,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 	}
 	return {
 		...await bootOwnedAvdOnFreshPort({
+			deviceSlotWait: flags.deviceSlotWait,
 			avdName: created.avdName,
 			metadata: created.created ? {
 				poolConfiguration: configuration,
@@ -472,41 +694,50 @@ 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, slot, deviceName, out, logFile = null, alive = pidExists }) {
-	const claim = claimAndroidConsolePort({
-		projectPath,
-		slot,
-		avdName,
-		deviceName,
-		livePorts: liveAndroidConsolePorts(),
-		metadata
-	});
-	const serial = `emulator-${claim.consolePort}`;
-	try {
-		reportAndroidMemoryPressure(out);
-		const pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
-		out(chalk.dim(phaseLine("device", `waiting for ${serial} to finish booting`)));
-		const result = await waitForAndroidBoot({
-			serial,
-			timeoutMs: ANDROID_FRESH_BOOT_TIMEOUT_MS,
-			pid,
-			alive,
-			out
+async function bootOwnedAvdOnFreshPort({ avdName, deviceSlotWait, metadata, projectPath, slot, deviceName, out, logFile = null, alive = pidExists }) {
+	return withDeviceBootAdmission({
+		platform: "android",
+		key: avdName
+	}, async () => {
+		const claim = claimAndroidConsolePort({
+			projectPath,
+			slot,
+			avdName,
+			deviceName,
+			livePorts: liveAndroidConsolePorts(),
+			metadata
 		});
-		if (result.failed) throw new AvdBootError(result.reason, result.remedy);
-		const running = getAvdNameForSerial(serial);
-		if (running && running !== avdName) throw new Error(`${serial} is running AVD ${running}, not this workspace's owned AVD ${avdName}; refusing to use it.`);
-		clearAndroidBootPending(projectPath, avdName, slot);
-		const { bootPending: _booted, ...booted } = claim;
-		return {
-			...booted,
-			serial,
-			setup: true
-		};
-	} catch (error) {
-		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-		throw error;
-	}
+		const serial = `emulator-${claim.consolePort}`;
+		try {
+			reportAndroidMemoryPressure(out);
+			const pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
+			out(chalk.dim(phaseLine("device", `waiting for ${serial} to finish booting`)));
+			const result = await waitForAndroidBoot({
+				serial,
+				timeoutMs: ANDROID_FRESH_BOOT_TIMEOUT_MS,
+				pid,
+				alive,
+				out
+			});
+			if (result.failed) throw new AvdBootError(result.reason, result.remedy);
+			const running = getAvdNameForSerial(serial);
+			if (running && running !== avdName) throw new Error(`${serial} is running AVD ${running}, not this workspace's owned AVD ${avdName}; refusing to use it.`);
+			clearAndroidBootPending(projectPath, avdName, slot);
+			const { bootPending: _booted, ...booted } = claim;
+			return {
+				...booted,
+				serial,
+				setup: true
+			};
+		} catch (error) {
+			releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+			throw error;
+		}
+	}, {
+		...deviceSlotWait,
+		root: projectPath,
+		out
+	});
 }
 function reportAndroidMemoryPressure(out) {
 	const pressure = readHostMemoryPressure();
@@ -515,11 +746,15 @@ function reportAndroidMemoryPressure(out) {
 function androidBootRemedy(pressure) {
 	let count = null;
 	try {
-		count = liveOwnedDeviceCount({
-			sims: process.platform === "darwin" ? listAllIosSims({ timeoutMs: 2e3 }) : [],
-			adbEmulators: listAdbDevices({ timeoutMs: 2e3 }).emulators,
-			config: loadConfig$1()
+		const live = countLiveOwnedDevices({
+			sims: () => process.platform === "darwin" ? listAllIosSims({ timeoutMs: 2e3 }) : [],
+			adb: () => ({
+				...listAdbDevices({ timeoutMs: 2e3 }),
+				unhealthy: []
+			}),
+			booting: []
 		});
+		count = typeof live === "number" ? live : null;
 	} catch {}
 	const observation = pressure === "warning" || pressure === "critical" ? `macOS reports ${pressure} host memory pressure. ` : "";
 	const devices = count ? `${count} Stim-owned ${count === 1 ? "device is" : "devices are"} running. ` : "";
@@ -557,7 +792,7 @@ async function waitForAndroidBoot({ serial, timeoutMs, pid = null, alive = pidEx
 		remedy: exited ? "Inspect the emulator log for the process exit, fix what it reports, then run `stim android` again." : androidBootRemedy(pressure)
 	};
 }
-async function ensureAndroidBooted({ device, projectPath, slot, timeoutMs, out, logFile = null, alive = pidExists }) {
+async function ensureAndroidBooted({ device, deviceSlotWait, projectPath, slot, timeoutMs, out, logFile = null, alive = pidExists }) {
 	if (!device?.avdName || !projectPath) return {
 		failed: true,
 		reason: "No owned Android emulator is recorded for this project."
@@ -595,36 +830,57 @@ async function ensureAndroidBooted({ device, projectPath, slot, timeoutMs, out,
 		timeoutMs,
 		out
 	}));
-	const claim = claimAndroidConsolePort({
-		projectPath,
-		slot,
-		avdName: device.avdName,
-		deviceName: device.deviceName,
-		livePorts: liveAndroidConsolePorts(),
-		metadata: device
-	});
-	const serial = `emulator-${claim.consolePort}`;
-	reportAndroidMemoryPressure(out);
-	out(chalk.dim(phaseLine("device", `booting ${device.avdName} as ${serial}`)));
-	let pid = null;
+	const boot = async () => {
+		const claim = claimAndroidConsolePort({
+			projectPath,
+			slot,
+			avdName,
+			deviceName: device.deviceName,
+			livePorts: liveAndroidConsolePorts(),
+			metadata: device
+		});
+		const serial = `emulator-${claim.consolePort}`;
+		reportAndroidMemoryPressure(out);
+		out(chalk.dim(phaseLine("device", `booting ${avdName} as ${serial}`)));
+		let pid = null;
+		try {
+			pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
+		} catch (e) {
+			releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+			return {
+				failed: true,
+				reason: `Could not start emulator for AVD ${avdName}: ${e?.message || e}`
+			};
+		}
+		const result = await waitForAndroidBoot({
+			serial,
+			timeoutMs,
+			pid,
+			alive,
+			out
+		});
+		if (result.failed) releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+		return booted(result);
+	};
 	try {
-		pid = bootAndroidEmulator(device.avdName, claim.consolePort, { logFile });
-	} catch (e) {
-		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+		return await withDeviceBootAdmission({
+			platform: "android",
+			key: avdName
+		}, boot, {
+			...deviceSlotWait,
+			root: projectPath,
+			out
+		});
+	} catch (error) {
+		const refusal = error instanceof DeviceAdmissionRefusal ? error : (0, ownership_claim_exports.claimFailure)(error, "stim android");
+		if (!refusal) throw error;
 		return {
 			failed: true,
-			reason: `Could not start emulator for AVD ${device.avdName}: ${e?.message || e}`
+			code: refusal.code,
+			reason: refusal.message,
+			remedy: refusal.remedy
 		};
 	}
-	const result = await waitForAndroidBoot({
-		serial,
-		timeoutMs,
-		pid,
-		alive,
-		out
-	});
-	if (result.failed) releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-	return booted(result);
 }
 //#endregion
 //#region src/engine/device.ts
@@ -668,9 +924,11 @@ async function ensureOwnedDevice({ platform, project, projectPath, slot, setting
 	});
 }
 const BOOT_POLL_MS = 500;
-async function ensureBooted({ platform, device, simulatorApp, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists, projectPath, slot } = {}) {
+async function ensureBooted({ platform, device, simulatorApp, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists, projectPath, slot, deviceSlotWait }) {
 	if (platform === "ios") return ensureIosBooted({
 		device,
+		projectPath,
+		deviceSlotWait,
 		simulatorApp,
 		timeoutMs: timeoutMs ?? 6e5,
 		pollMs,
@@ -678,6 +936,7 @@ async function ensureBooted({ platform, device, simulatorApp, timeoutMs, pollMs
 	});
 	if (platform === "android") return ensureAndroidBooted({
 		device,
+		deviceSlotWait,
 		projectPath,
 		slot,
 		timeoutMs: timeoutMs ?? ANDROID_BOOT_TIMEOUT_MS,
@@ -1523,4 +1782,4 @@ function planFlagRefusal(flag) {
 	};
 }
 //#endregion
-export { AvdRecoveryError as _, refusePlan as a, skippedMissReason as c, refreshUpdatesManifestFile as d, swapJsBundle as f, AvdBootError as g, ensureOwnedDevice as h, printPlan as i, UPDATES_MANIFEST_NAME as l, ensureBooted as m, planFlagRefusal as n, explainBuildMiss as o, didSetUpDevice as p, planPayload as r, fingerprintErrorMissReason as s, planCachedBuild as t, detectEntryFile as u, warmMetro as v };
+export { AvdRecoveryError as _, refusePlan as a, devicePlacementLine as b, skippedMissReason as c, refreshUpdatesManifestFile as d, swapJsBundle as f, AvdBootError as g, ensureOwnedDevice as h, printPlan as i, UPDATES_MANIFEST_NAME as l, ensureBooted as m, planFlagRefusal as n, explainBuildMiss as o, didSetUpDevice as p, planPayload as r, fingerprintErrorMissReason as s, planCachedBuild as t, detectEntryFile as u, warmMetro as v, automaticDevicePlacement as y };