stim 1.3.0 → 1.4.0

package/dist/device-CMDFzx7C.mjs

@@ -0,0 +1,1136 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { C as withConfigLock, E as ownership_claim_exports, F as deviceSlotPlatforms, L as projectDeviceSlots, T as acquireAvdClaim, _ as releaseAndroidConsolePort, b as setDevice, g as loadConfig, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, w as process_identity_exports, y as saveConfig } from "./config-6vdGngKa.mjs";
+import { g as workspaceId } from "./workspace-state-Do1e2mOH.mjs";
+import { s as ownedDeviceLabel } from "./project-CBFCwnN5.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { r as pidExists } from "./metro-DFLmaVz8.mjs";
+import { l as phaseLine } from "./command-output-BuIb_ZOI.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-BkM4qTaN.mjs";
+import { l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-DwfltIXQ.mjs";
+import { c as isLegacyDeletionClaim, d as selectParked, i as teardownParkedIosSim, l as parkedMaxSetting, o as adoptParked, r as teardownParkedAvd, s as dropParked, t as teardownOwnedAvd, u as readParked } from "./teardown-KsPpvldq.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-UEIrvZMJ.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 { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { claimRemoveCommand, clearClaimChild, markClaimChildPending, processGroupAlive, releaseClaim, setClaimChild } from "@stim-cli/core/ownership-claim";
+import { captureProcessIdentity } from "@stim-cli/core/process-identity";
+import { isDeepStrictEqual } from "node:util";
+import chalk from "chalk";
+//#region src/engine/simslim.ts
+async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
+	if (!profile && !previouslyManaged) return {
+		managed: false,
+		profile: null
+	};
+	const action = profile ? "on" : "off";
+	const args = profile ? [
+		"on",
+		udid,
+		"--profile",
+		profile
+	] : ["off", udid];
+	const lines = [];
+	const onLine = (raw) => {
+		const line = stripAnsi(raw).trim();
+		if (!line) return;
+		lines.push(line);
+		if (lines.length > 20) lines.shift();
+		out(`SimSlim: ${line}`);
+	};
+	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 = (0, ownership_claim_exports.tryAcquireClaim)({
+		root,
+		mode: "exclusive",
+		label
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new ownership_claim_exports.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 && (0, process_identity_exports.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 && (0, ownership_claim_exports.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 {
+		(0, ownership_claim_exports.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 = (0, process_identity_exports.captureProcessIdentity)(child.pid);
+			if (captured.ok) {
+				identity = {
+					pid: child.pid,
+					processToken: captured.token
+				};
+				try {
+					(0, ownership_claim_exports.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: ${(0, ownership_claim_exports.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()) (0, ownership_claim_exports.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);
+	}
+	stdout.flush();
+	stderr.flush();
+	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}`);
+	}
+	return {
+		managed: Boolean(profile),
+		profile: profile ?? null
+	};
+}
+function simslimLaunchError(error) {
+	const cause = error;
+	if (cause?.code === "ENOENT") return new Error("SimSlim is configured but the `simslim` command is not installed. Run `brew install mobai-app/tap/simslim`.", { cause });
+	return new Error(`Could not start SimSlim: ${String(cause?.message || cause)}`, { cause });
+}
+function simslimIsOnPath() {
+	try {
+		return Boolean(getExecutor().runQuiet("command -v simslim", { timeoutMs: 5e3 }));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/engine/android-avd-setup.ts
+var AvdBootError = class extends Error {
+	remedy;
+	constructor(message, remedy, cause) {
+		super(message, { cause });
+		this.remedy = remedy;
+	}
+};
+var AvdRecoveryError = class extends AvdBootError {};
+function findOtherOwner(avdName, projectPath, selectedSlot = "default") {
+	for (const [path, project] of Object.entries(loadConfig()?.projects ?? {})) if (projectDeviceSlots(project).some(({ slot, platforms }) => (path !== projectPath || slot !== selectedSlot) && platforms.android?.avdName?.toLowerCase() === avdName.toLowerCase())) return path;
+	return null;
+}
+async function prepareOwnedAvd({ projectPath, slot, label, previousAvdName, systemImage, configuration, configure, teardown = teardownOwnedAvd }) {
+	const { claim, reservation, previous, avdName } = withConfigLock(() => {
+		const previous = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.android;
+		if (previous?.avdName && previous.avdName !== previousAvdName) throw new Error(`Another Stim run assigned AVD ${previous.avdName} to this workspace. Retry to use it.`);
+		if (readParked("android").some((entry) => entry.name === ownedAvdName(label)) || findOtherOwner(ownedAvdName(label), projectPath, slot)) label = `${label}-${randomUUID().slice(0, 8)}`;
+		const avdName = ownedAvdName(label);
+		const claim = acquireAvdClaim(avdName);
+		const reservation = {
+			avdName,
+			owned: true,
+			deviceName: avdName,
+			setupIncomplete: true,
+			poolConfiguration: configuration
+		};
+		try {
+			setDevice(projectPath, "android", reservation, slot);
+			return {
+				claim,
+				reservation,
+				previous,
+				avdName
+			};
+		} catch (error) {
+			releaseClaim(claim);
+			throw error;
+		}
+	});
+	const currentRecord = () => deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.android;
+	const assertReservation = () => {
+		if (readParked("android").some((entry) => entry.name === avdName)) throw new Error(`AVD ${avdName} was parked by another Stim run. Retry to adopt it safely.`);
+		const owner = findOtherOwner(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.`);
+		const current = currentRecord();
+		if (!isDeepStrictEqual(current, reservation)) {
+			const state = current?.setupIncomplete ? "has incomplete setup" : "was registered or removed";
+			throw new Error(`AVD ${current?.avdName ?? avdName} ${state} by another concurrent Stim run. Retry after that run finishes so the recorded device is resolved safely.`);
+		}
+	};
+	let prepared;
+	let child;
+	const creationRunning = () => child?.pid !== void 0 && processGroupAlive(child.pid);
+	let configurationFailure;
+	try {
+		try {
+			const creation = await createOwnedAvd(label, {
+				systemImage,
+				spawn: (...args) => {
+					markClaimChildPending(claim);
+					child = getExecutor().spawn(...args);
+					if (child.pid !== void 0) {
+						const captured = captureProcessIdentity(child.pid);
+						if (captured.ok) try {
+							setClaimChild(claim, {
+								pid: child.pid,
+								processToken: captured.token
+							});
+						} catch {}
+					}
+					return child;
+				}
+			}).then((result) => ({ result }), (error) => ({ error }));
+			if (creationRunning()) throw new AvdRecoveryError(`AVD ${avdName} creation left its process group running (pid ${child.pid}); its reservation remains incomplete.`, `Wait for process group ${child.pid} to finish before retrying stim android. If its identity could not be recorded, inspect the group and remove the claim only after it stops: ${claimRemoveCommand(claim.path)}`);
+			clearClaimChild(claim);
+			if ("error" in creation) throw creation.error;
+			prepared = {
+				...creation.result,
+				created: true
+			};
+		} catch (error) {
+			const message = String(error?.message || error);
+			if (!message.includes("already exists")) throw error;
+			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.", error);
+				withConfigLock(assertReservation);
+				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: error });
+				if (!resolved.serial) assertOwnedAvdStopped(avdName);
+				prepared = {
+					avdName,
+					created: false,
+					systemImage: ownedAvdSystemImage(avdName),
+					...resolved.serial ? {
+						serial: resolved.serial,
+						consolePort: Number(resolved.serial.replace(/^emulator-/, ""))
+					} : {}
+				};
+			} catch (recoveryError) {
+				withConfigLock(() => {
+					if (!isDeepStrictEqual(currentRecord(), reservation)) return;
+					if (previous) setDevice(projectPath, "android", previous, slot);
+					else clearDevice(projectPath, "android", slot, avdName);
+				});
+				if (recoveryError instanceof AvdRecoveryError) throw recoveryError;
+				throw new AvdRecoveryError(`Could not recover owned AVD ${avdName}: ${String(recoveryError?.message || recoveryError)}`, "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.", recoveryError);
+			}
+		}
+		if (prepared.created) try {
+			configure(avdName);
+		} catch (error) {
+			configurationFailure = { error };
+		}
+		if (!configurationFailure) withConfigLock(() => {
+			assertReservation();
+			setDevice(projectPath, "android", {
+				avdName,
+				owned: true,
+				deviceName: avdName,
+				...prepared.created ? { poolConfiguration: configuration } : {},
+				...prepared.consolePort ? { consolePort: prepared.consolePort } : {}
+			}, slot);
+		});
+	} finally {
+		if (!creationRunning()) releaseClaim(claim);
+		else {
+			child?.stdout?.destroy();
+			child?.stderr?.destroy();
+			child?.unref();
+		}
+	}
+	if (configurationFailure) {
+		const { error } = configurationFailure;
+		const cleanup = teardown(avdName, {
+			del: true,
+			owner: {
+				projectPath,
+				slot,
+				expectedRecord: reservation
+			},
+			onRemoved: () => {
+				clearDevice(projectPath, "android", slot, avdName);
+			}
+		});
+		const orphan = cleanup.status === "failed" || cleanup.status === "skipped" ? ` 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 ${avdName}, but could not configure its AVD settings: ${String(error?.message || error)}${orphan}`, { cause: error });
+	}
+	return prepared;
+}
+//#endregion
+//#region src/engine/device.ts
+function startIosBoot(udid, configure, label, out) {
+	const done = (async () => {
+		await bootIosSim(udid, {
+			label,
+			out
+		});
+		await configure();
+	})();
+	done.catch(() => {});
+	return {
+		udid,
+		done
+	};
+}
+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,
+		flags,
+		note,
+		out,
+		reconcileIosSimulator
+	});
+	return ensureOwnedAndroidDevice({
+		record,
+		projectPath,
+		slot,
+		settingsRoot,
+		label,
+		settings,
+		flags,
+		note,
+		out,
+		logFile,
+		alive,
+		configureAvd,
+		teardownAvd
+	});
+}
+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 by name -- 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 Error(`${mismatch}. Stim will not silently boot a different model. Run \`stim worktree remove\` (or \`stim gc --delete\`) to reap the current sim, then \`stim ios\` again to create the requested one.`);
+				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 } : {}
+				};
+				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),
+						...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);
+		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);
+	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 } : {}
+		};
+		if (!adoptParked({
+			platform: "ios",
+			projectPath,
+			slot,
+			udid: parked.udid,
+			device
+		})) continue;
+		try {
+			renameIosSim(parked.udid, name);
+		} catch {}
+		return 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 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 avdName = record.avdName;
+		const cleanup = teardownAvd(avdName, {
+			del: true,
+			owner: {
+				projectPath,
+				slot,
+				expectedRecord: record
+			},
+			onRemoved: () => {
+				clearDevice(projectPath, "android", slot, avdName);
+			}
+		});
+		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new AvdRecoveryError(`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.`, "Wait for any active AVD operation to finish. If the refusal names an unresolved claim, inspect its creator and native processes before removing only that claim. Retry `stim android` to reconcile the incomplete device.");
+		record = null;
+	}
+	if (record?.avdName) {
+		if (record.owned) {
+			const resolved = resolveOwnedAvdSerial(record.avdName);
+			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,
+					consolePort,
+					owned: true,
+					deviceName: record.deviceName ?? record.avdName
+				};
+				setDevice(projectPath, "android", updated, slot);
+				return {
+					...updated,
+					systemImage: ownedAvdSystemImage(record.avdName)
+				};
+			} else if (!resolved.missing) {
+				out(chalk.dim(`Recorded port for owned AVD ${record.avdName} is not currently ours; booting it on a freshly allocated port...`));
+				return {
+					...await bootOwnedAvdOnFreshPort({
+						avdName: record.avdName,
+						metadata: record,
+						projectPath,
+						slot,
+						deviceName: record.deviceName,
+						out,
+						logFile,
+						alive
+					}),
+					systemImage: ownedAvdSystemImage(record.avdName)
+				};
+			}
+		} else if (listAvds().includes(record.avdName)) {
+			if (!listAdbDevices().emulators.some((e) => e.consolePort === record.consolePort)) {
+				note(chalk.yellow(`Note: assigned AVD ${record.avdName} (emulator-${record.consolePort}) 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 AVD."));
+			}
+			return record;
+		}
+	} else if (record?.serial) {
+		note(chalk.yellow(`Note: this project has a stored assignment to physical device ${record.serial}, which Stim no longer keeps.`));
+		note(chalk.dim("Creating an owned emulator instead. Pass `--device` to build for a connected device."));
+	}
+	if (parkedMaxSetting("android").max > 0) {
+		const systemImage = pickDefaultSystemImage(listInstalledSystemImages(), { systemImage: flags.systemImage || settings.android?.systemImage })?.pkg;
+		const candidates = readParked("android").filter((entry) => entry.systemImage === systemImage && entry.configuration === configuration).toSorted((a, b) => a.parkedAt.localeCompare(b.parkedAt));
+		for (const parked of candidates) {
+			if (isLegacyDeletionClaim(parked.deletionClaim)) continue;
+			const resolved = resolveOwnedAvdSerial(parked.name);
+			if (resolved.missing) {
+				const result = teardownParkedAvd(parked.name);
+				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
+				continue;
+			}
+			if (resolved.notOwned || resolved.serial) continue;
+			try {
+				assertOwnedAvdStopped(parked.name);
+			} catch (error) {
+				out(phaseLine("device", `kept parked ${parked.name}: ${String(error?.message || error)}`));
+				continue;
+			}
+			if (ownedAvdSystemImage(parked.name) !== systemImage || !ownedAvdMatchesConfiguration(parked.name, configuration)) {
+				const result = teardownParkedAvd(parked.name);
+				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
+				continue;
+			}
+			const adopted = {
+				avdName: parked.name,
+				deviceName: parked.name,
+				owned: true,
+				poolConfiguration: configuration,
+				adoptionPending: true
+			};
+			if (!adoptParked({
+				platform: "android",
+				projectPath,
+				slot,
+				udid: parked.udid,
+				device: adopted
+			})) continue;
+			return {
+				...await bootOwnedAvdOnFreshPort({
+					avdName: parked.name,
+					projectPath,
+					slot,
+					metadata: adopted,
+					out,
+					logFile,
+					alive
+				}),
+				adopted: true,
+				systemImage
+			};
+		}
+	}
+	const created = await prepareOwnedAvd({
+		projectPath,
+		slot,
+		label,
+		previousAvdName: record?.avdName,
+		systemImage: flags.systemImage || settings.android?.systemImage || void 0,
+		configuration,
+		configure: (avdName) => configureAvd(avdName, {
+			dataPartitionSizeGb: androidDataPartitionSizeGbSetting(settings),
+			avdConfig
+		}),
+		teardown: teardownAvd
+	});
+	if (!created.created) {
+		out(chalk.dim(phaseLine("device", `recovered ${created.avdName} (unrecorded from a prior run)`)));
+		if (created.serial) return {
+			...created,
+			owned: true,
+			deviceName: created.avdName
+		};
+	}
+	return {
+		...await bootOwnedAvdOnFreshPort({
+			avdName: created.avdName,
+			metadata: created.created ? { poolConfiguration: configuration } : void 0,
+			projectPath,
+			slot,
+			deviceName: created.avdName,
+			out,
+			logFile,
+			alive
+		}),
+		created: created.created,
+		systemImage: created.systemImage
+	};
+}
+function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
+	return lock(() => {
+		const consolePort = nextConsolePort([...recordedPorts(), ...livePorts]);
+		const claim = {
+			...metadata?.poolConfiguration ? { poolConfiguration: metadata.poolConfiguration } : {},
+			...metadata?.adoptionPending ? { adoptionPending: true } : {},
+			avdName,
+			consolePort,
+			owned: true,
+			deviceName: deviceName ?? avdName
+		};
+		record(projectPath, "android", claim, slot);
+		return claim;
+	});
+}
+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: 12e4,
+			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.`);
+		return {
+			...claim,
+			serial
+		};
+	} catch (error) {
+		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+		throw error;
+	}
+}
+function reportAndroidMemoryPressure(out) {
+	const pressure = readHostMemoryPressure();
+	if (pressure === "warning" || pressure === "critical") out(chalk.dim(phaseLine("memory", `macOS reports ${pressure} host memory pressure; emulator boot may be slow. Free memory with \`stim stop\` only in workspaces you own; ask before closing other apps or devices.`)));
+}
+function androidBootRemedy(pressure) {
+	let count = null;
+	try {
+		count = liveOwnedDeviceCount({
+			sims: process.platform === "darwin" ? listAllIosSims({ timeoutMs: 2e3 }) : [],
+			adbEmulators: listAdbDevices({ timeoutMs: 2e3 }).emulators,
+			config: loadConfig()
+		});
+	} 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. ` : "";
+	if (observation || devices) return `${observation}${devices}Stop an unneeded device with \`stim stop\` only in a workspace you own, then run \`stim android\` again; ask before closing other apps or devices. These observations do not establish the cause of the timeout or an OOM crash.`;
+	return "Inspect the emulator log and run `stim doctor` to check JAVA_HOME, ANDROID_HOME, and installed system images, then run `stim android` again.";
+}
+async function waitForAndroidBoot({ serial, timeoutMs, pid = null, alive = pidExists, out }) {
+	const aborted = () => pid !== null && !alive(pid);
+	const wait = (windowMs) => waitForBoot(serial, windowMs, {
+		aborted,
+		commandTimeoutMs: 5e3
+	});
+	let result = await wait(timeoutMs);
+	if (result.ok) return {
+		ok: true,
+		serial
+	};
+	let pressure = readHostMemoryPressure();
+	let elapsedMs = timeoutMs;
+	if (!result.exited && pid !== null && !aborted() && (pressure === "warning" || pressure === "critical")) {
+		const extensionMs = 24e4;
+		out(chalk.dim(phaseLine("memory", `macOS reports ${pressure} host memory pressure; retrying the boot wait once for the same live emulator ${serial} (up to ${extensionMs / 1e3}s more).`)));
+		result = await wait(extensionMs);
+		if (result.ok) return {
+			ok: true,
+			serial
+		};
+		elapsedMs += extensionMs;
+		pressure = readHostMemoryPressure();
+	}
+	const exited = result.exited || aborted();
+	return {
+		failed: true,
+		reason: `${exited ? `The emulator process for ${serial} exited before the device finished booting.` : `Emulator ${serial} did not finish booting within ${Math.round(elapsedMs / 1e3)}s.`} Diagnostic: ${JSON.stringify(result.diagnostic)}`,
+		remedy: exited ? "Inspect the emulator log for the process exit, fix what it reports, then run `stim android` again." : androidBootRemedy(pressure)
+	};
+}
+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 || {})) 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, slot = "default", sims = [], adbEmulators = [] } = {}) {
+	if (!platform) return false;
+	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, 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;
+	const count = liveOwnedDeviceCount({
+		sims,
+		adbEmulators,
+		config
+	});
+	if (count < max) return null;
+	return {
+		code: "STIM_AT_CAPACITY",
+		message: `${count} Stim device(s) are already booted and concurrency.maxDevices is ${max}, so booting another would exceed the cap.`,
+		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
+	};
+}
+function checkDeviceCapacity({ platform, project, slot = "default", max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
+	if (!max || max <= 0) return null;
+	let simList = [];
+	let adbRes = {
+		emulators: [],
+		physical: [],
+		unhealthy: []
+	};
+	try {
+		simList = typeof sims === "function" ? sims() || [] : sims || [];
+	} catch {}
+	try {
+		adbRes = typeof adb === "function" ? adb() || adbRes : adb || adbRes;
+	} catch {}
+	let cfg = null;
+	try {
+		cfg = typeof config === "function" ? config() : config ?? null;
+	} catch {}
+	return deviceCapacityRefusal({
+		platform,
+		project,
+		slot,
+		max,
+		sims: simList,
+		adb: adbRes,
+		config: cfg
+	});
+}
+function deviceTypeMismatch(recordedTypeId, requestedName, deviceTypes) {
+	if (!requestedName || !recordedTypeId) return null;
+	const wanted = (deviceTypes || []).find((d) => d.name === requestedName);
+	if (!wanted) return null;
+	if (wanted.identifier === recordedTypeId) return null;
+	const recorded = (deviceTypes || []).find((d) => d.identifier === recordedTypeId);
+	return `this project's sim is ${recorded ? recorded.name : recordedTypeId}, but --device-type asked for ${requestedName}`;
+}
+function installedNames(names) {
+	const unique = [...new Set(names.filter((n) => typeof n === "string" && n !== ""))];
+	return unique.length > 0 ? unique.join(", ") : "none";
+}
+function unknownIosRuntimeRefusal(requested, runtimes) {
+	if (!requested) return null;
+	if ((runtimes || []).some((r) => iosRuntimeMatches(r, requested))) return null;
+	return {
+		message: `No installed simulator runtime matches "${requested}". Installed runtimes: ${installedNames((runtimes || []).map((r) => r.version))}.`,
+		remedy: "Pass `--runtime` (or set ios.runtime) a version printed above (\"26.5\") or a runtime's full name (\"iOS 26.5\"); nothing else matches. Install more runtimes through Xcode."
+	};
+}
+function creatableIosDeviceTypeNames(runtimes, runtime) {
+	return (runtime ? (runtimes || []).filter((r) => iosRuntimeMatches(r, runtime)) : runtimes || []).flatMap((r) => (r.supportedDeviceTypes || []).map((d) => d.name));
+}
+function unknownIosDeviceTypeRefusal(requested, runtimes, runtime) {
+	if (!requested) return null;
+	const creatable = creatableIosDeviceTypeNames(runtimes, runtime);
+	if (creatable.includes(requested)) return null;
+	return {
+		message: `No device type named "${requested}" can be created on ${runtime ? `runtime ${runtime}` : "any installed simulator runtime"}. ${runtime ? `Device types runtime ${runtime} supports` : "Device types the installed runtimes support"}: ${installedNames(creatable)}.`,
+		remedy: "Pass `--device-type` (or set ios.deviceType) one of the names printed above, exactly as `xcrun simctl list devicetypes` spells it. `xcrun simctl list devicetypes` also lists watchOS, tvOS and visionOS models, which no iOS runtime can create. Install more models through Xcode."
+	};
+}
+function unknownAndroidSystemImageRefusal(requested, images) {
+	if (!requested) return null;
+	if ((images || []).some((i) => i.pkg === requested)) return null;
+	return {
+		message: `No installed Android system image is named "${requested}". Installed system images: ${installedNames((images || []).map((i) => i.pkg))}.`,
+		remedy: "Pass `--system-image` (or set android.systemImage) to one of the package ids printed above. Install more with `sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`."
+	};
+}
+const BOOT_POLL_MS = 500;
+async function ensureBooted({ platform, device, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists } = {}) {
+	if (platform === "ios") return ensureIosBooted({
+		device,
+		timeoutMs: timeoutMs ?? 6e5,
+		pollMs,
+		out
+	});
+	if (platform === "android") return ensureAndroidBooted({
+		device,
+		timeoutMs: timeoutMs ?? 24e4,
+		out,
+		logFile,
+		alive
+	});
+	return {
+		failed: true,
+		reason: `Unknown platform "${platform}".`
+	};
+}
+async function ensureIosBooted({ device, 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") return ready();
+	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
+	const bootDeadline = Date.now() + timeoutMs;
+	try {
+		await bootIosSim(udid, {
+			timeoutMs,
+			label: sim.name,
+			out
+		});
+	} 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.`
+	};
+}
+async function ensureAndroidBooted({ device, timeoutMs, out, logFile = null, alive = pidExists }) {
+	if (!device?.avdName) return {
+		failed: true,
+		reason: "No owned Android emulator is recorded for this project."
+	};
+	let resolved;
+	try {
+		resolved = resolveOwnedAvdSerial(device.avdName);
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not list AVDs: ${e?.message || e}`
+		};
+	}
+	if (resolved.missing) return {
+		failed: true,
+		reason: `AVD ${device.avdName} no longer exists. Run \`stim android\` again to create a fresh owned AVD.`
+	};
+	if (resolved.notOwned) return {
+		failed: true,
+		reason: `AVD ${device.avdName} is not Stim-owned by name; refusing to boot it.`
+	};
+	if (resolved.serial) return waitForAndroidBoot({
+		serial: resolved.serial,
+		timeoutMs,
+		out
+	});
+	const freshSerial = `emulator-${device.consolePort}`;
+	if (device.owned && device.serial === freshSerial) return waitForAndroidBoot({
+		serial: freshSerial,
+		timeoutMs,
+		out
+	});
+	const serial = `emulator-${pickConsolePort(device.consolePort)}`;
+	reportAndroidMemoryPressure(out);
+	out(chalk.dim(phaseLine("device", `booting ${device.avdName} as ${serial}`)));
+	let pid = null;
+	try {
+		pid = bootAndroidEmulator(device.avdName, Number(serial.replace(/^emulator-/, "")), { logFile });
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not start emulator for AVD ${device.avdName}: ${e?.message || e}`
+		};
+	}
+	return waitForAndroidBoot({
+		serial,
+		timeoutMs,
+		pid,
+		alive,
+		out
+	});
+}
+function pickConsolePort(recorded) {
+	const live = liveAndroidConsolePorts();
+	if (recorded && !live.includes(Number(recorded))) return Number(recorded);
+	return nextConsolePort([...allConsolePortsAndSerials().androidConsolePorts, ...live]);
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#endregion
+export { liveOwnedDeviceCount as a, unknownIosRuntimeRefusal as c, simslimIsOnPath as d, ensureOwnedDevice as i, AvdBootError as l, clearIosAdoptionPending as n, unknownAndroidSystemImageRefusal as o, ensureBooted as r, unknownIosDeviceTypeRefusal as s, checkDeviceCapacity as t, AvdRecoveryError as u };