stim 1.8.0 → 1.10.0

package/dist/{device-BUoZyMoR.mjs → dev-client-92U593KT.mjs}

@@ -1,318 +1,160 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { C as withConfigLock, E as ownership_claim_exports, I as deviceSlotPlatforms, R 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-B7iyKWkL.mjs";
-import { g as workspaceId } from "./workspace-state-BT5E3SA2.mjs";
-import { s as ownedDeviceLabel } from "./project-DDZWf_16.mjs";
-import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Dl5uKE03.mjs";
-import { i as pidExists } from "./metro-C7bcJ0uo.mjs";
-import { l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-BXXorVM2.mjs";
-import { A as ownedAvdName, B as waitForBoot, C as listAvds, D as nextConsolePort, I as resolveOwnedAvdSerial, N as pickDefaultSystemImage, S as listAdbDevices, b as getAvdNameForSerial, c as assertOwnedAvdStopped, f as bootAndroidEmulator, j as ownedAvdSystemImage, k as ownedAvdMatchesConfiguration, m as createOwnedAvd, p as configureNewOwnedAvd, u as avdPoolConfiguration, w as listInstalledSystemImages } from "./android-DWssqHQ8.mjs";
-import { l as phaseLine } from "./command-output-B3ycpsYv.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-BJqEzPo_.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
-import { D as hostMemoryPressureAdvice, O as readHostMemoryPressure, T as configuredIosSimulatorViewer, _ 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-BcCiI4TS.mjs";
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { H as projectDeviceSlots, O as acquireAvdClaim, S as setDevice, T as withConfigLock$1, g as loadConfig$1, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, v as releaseAndroidConsolePort, x as saveConfig, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { g as updateWorkspaceState, i as pidExists, k as workspaceId, m as readWorkspaceState$1, s as resolveProjectMetro, x as ensureWorkspaceStorage } from "./metro-BWLOJ_Wr.mjs";
+import { D as makeTemporaryDirectory, O as removeTemporaryEntry } from "./worktree-BlizKDpZ.mjs";
+import { a as detectIsExpo, c as ownedDeviceLabel, s as isPackageResolvable } from "./project-BXZzOABt.mjs";
+import { n as spawnDeclared } from "./spawn-claims-CUleC2cM.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { l as phaseLine } from "./command-output-D5z2_bcF.mjs";
+import { E as listInstalledSystemImages, I as pickDefaultSystemImage, M as ownedAvdName, P as ownedAvdSystemImage, T as listAvds, W as waitForBoot, d as avdPoolConfiguration, h as createOwnedAvd, j as ownedAvdMatchesConfiguration, k as nextConsolePort, l as assertOwnedAvdStopped, m as configureNewOwnedAvd, p as bootAndroidEmulator, w as listAdbDevices, x as getAvdNameForSerial, z as resolveOwnedAvdSerial } from "./android-787HhP5w.mjs";
+import { l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-DOugPlPz.mjs";
+import { _ as dropParked, b as readParked, d as teardownOwnedAvd, g as adoptParked, m as teardownParkedIosSim, p as teardownParkedAvd, v as isLegacyDeletionClaim, x as selectParked, y as parkedMaxSetting } from "./ownership-DZjdx8Gq.mjs";
+import { E as configuredIosSimulatorViewer, O as hostMemoryPressureAdvice, S as resolveOwnedIosSim, b as resetIosPrivacy, c as iosSimulatorFailureAdvice, d as listIosDeviceTypes, g as parseRuntimeVersion, k as readHostMemoryPressure, l as listAllIosSims, m as ownedSimName, n as bootIosSim, r as createOwnedIosSim, v as renameIosSim, x as resolveIosCreation, y as resetIosKeychain } from "./ios-B2Fpqvlb.mjs";
+import { i as expoBinRefusal, r as expoBinPath, t as cleanLine } from "./server-expo-BvOCeakp.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-CQS_Kg-C.mjs";
+import { a as liveOwnedDeviceCount, i as deviceTypeMismatch, t as reconcileSimSlim } from "./simslim-Ca3487H6.mjs";
+import { s as startDevServer } from "./start-F9gv5dcC.mjs";
+import { d as startBuildHeartbeat, f as tailLines, n as HEARTBEAT_INTERVAL_MS } from "./xcode-B2tBkf0m.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { isJsonObject, readIdleStop, readJsonObject } from "@stim-cli/core/state";
+import { basename, 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 { randomUUID } from "node:crypto";
 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
+import { isDeepStrictEqual } from "node:util";
+import { request } from "node:http";
+//#region src/engine/metro-warmup.ts
+const WARMUP_TIMEOUT_MS = 6e4;
+async function requestLocal(url, platform, prefetch) {
+	return new Promise((resolve) => {
+		const req = request(url, { headers: {
+			accept: "application/json",
+			"expo-platform": platform,
+			...prefetch ? { "x-stim-metro-warmup": "1" } : {}
+		} });
+		const timer = setTimeout(() => req.destroy(), WARMUP_TIMEOUT_MS);
+		timer.unref();
+		req.on("socket", (socket) => socket.unref());
+		req.on("error", () => resolve(null));
+		req.on("close", () => {
+			clearTimeout(timer);
+			resolve(null);
+		});
+		req.on("response", (res) => {
+			let body = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => {
+				if (!prefetch) body += chunk;
 			});
-		} 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;
+			res.on("error", () => resolve(null));
+			res.on("end", () => resolve(res.statusCode === 200 ? body : null));
 		});
-		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" });
+		req.end();
+	});
+}
+async function warmMetro({ port, platform, isExpo, appId, bundleUrl }) {
+	try {
+		const origin = `http://127.0.0.1:${port}`;
+		if (await requestLocal(new URL("/_stim/metro-warmup", origin), platform, false) !== "ready") return;
+		const url = new URL("/index.bundle", origin);
+		url.search = new URLSearchParams({
+			platform,
+			dev: "true",
+			lazy: "true",
+			minify: "false",
+			...platform === "ios" ? { inlineSourceMap: "false" } : {},
+			modulesOnly: "false",
+			runModule: "true",
+			excludeSource: "true",
+			sourcePaths: "url-server",
+			...appId ? { app: appId } : {}
+		}).toString();
+		if (!bundleUrl && isExpo) {
+			const body = await requestLocal(new URL(origin), platform, false);
+			if (body === null) return;
+			const manifest = JSON.parse(body);
+			bundleUrl = manifest.launchAsset?.url ?? manifest.bundleUrl;
+			if (typeof bundleUrl !== "string") return;
 		}
-	} finally {
-		if (!child || settled()) (0, ownership_claim_exports.releaseClaim)(claim);
-		else {
-			child.stdout?.destroy?.();
-			child.stderr?.destroy?.();
-			child.unref();
+		if (bundleUrl) {
+			const bundle = new URL(bundleUrl, origin);
+			url.pathname = bundle.pathname;
+			url.search = bundle.search;
 		}
-		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}`);
-	}
+		await requestLocal(url, platform, true);
+	} catch {}
+}
+//#endregion
+//#region src/commands/native-runtime.ts
+const sleep$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function ensureDevServer({ root, port, settings, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
+	const held = port === null ? null : (await resolve(port, root)).metro;
+	if (port !== null && held) return {
+		ok: true,
+		port,
+		pid: held.pid ?? null,
+		devServer: null,
+		reclaimed: []
+	};
+	const reason = readIdleStop(readState(root)) ? "stopped (idle)" : "not running";
+	note(chalk.dim(phaseLine("metro", `dev server ${reason}; starting it${remote ? " for a remote device" : ""}`)));
+	const result = await start({
+		root,
+		settings,
+		remote,
+		out: note,
+		note
+	});
+	if (!result.ok) return {
+		ok: false,
+		code: result.error.code,
+		message: `Could not start this workspace's dev server: ${result.error.message}`,
+		remedy: result.error.remedy,
+		lines: result.lines,
+		reclaimed: result.reclaimed
+	};
+	const { facts } = result;
 	return {
-		managed: Boolean(profile),
-		profile: profile ?? null
+		ok: true,
+		port: facts.port,
+		pid: facts.supervisorPid,
+		devServer: facts.alreadyRunning ? null : {
+			started: true,
+			reason
+		},
+		reclaimed: result.reclaimed
 	};
 }
-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() {
+async function ensureWorkspaceStorageSafely(root, { note = (_line) => {} } = {}) {
 	try {
-		return Boolean(getExecutor().findExecutable("simslim"));
-	} 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;
+		return ensureWorkspaceStorage(root);
+	} catch (err) {
+		note(chalk.dim(`Could not prepare this workspace's Stim state: ${err?.message || err}`));
+		throw err;
 	}
-};
-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.`);
-		}
+function launchOutcomeRecord({ launchState, release, bundleId, configuration, metroPort }) {
+	const unverified = launchState === LAUNCH_UNVERIFIED;
+	const bundling = launchState === LAUNCH_BUNDLING;
+	let msg;
+	if (release) msg = unverified ? `${bundleId} could not be verified as running after its ${configuration} launch` : `${bundleId} is running its embedded ${configuration} bundle`;
+	else if (unverified) msg = `no bundle request from ${bundleId} reached this workspace's Metro on port ${metroPort}`;
+	else if (bundling) msg = `${bundleId} requested a bundle from this workspace's Metro on port ${metroPort}; it was still being built when the launch check ended`;
+	else msg = `${bundleId} fetched a bundle from this workspace's Metro on port ${metroPort}`;
+	return {
+		src: "build",
+		level: unverified ? "warn" : "info",
+		event: unverified ? "launch_unverified" : bundling ? "launch_bundling" : "launch_verified",
+		msg
 	};
-	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;
+}
+function isPhysicalDeviceRequest(flag) {
+	return flag !== null && flag !== void 0 && flag !== false;
 }
 //#endregion
-//#region src/engine/device.ts
-const ANDROID_FRESH_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 12e4;
-const ANDROID_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 24e4;
+//#region src/engine/device-ios.ts
 function startIosBoot(udid, configure, label, out, simulatorApp) {
 	const done = (async () => {
 		await bootIosSim(udid, {
@@ -328,37 +170,6 @@ function startIosBoot(udid, configure, label, out, simulatorApp) {
 		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)));
@@ -425,8 +236,8 @@ async function ensureOwnedIosDevice({ record, projectPath, slot, settingsRoot, l
 				return record;
 			}
 		}
-		withConfigLock(() => {
-			const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.ios;
+		withConfigLock$1(() => {
+			const current = deviceSlotPlatforms(loadConfig$1()?.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);
@@ -502,7 +313,7 @@ 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 ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
+	for (const project of Object.values(loadConfig$1()?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
 		const record = platforms.ios;
 		if (record?.deviceUdid !== udid && record?.deviceName) names.add(record.deviceName);
 	}
@@ -574,8 +385,8 @@ function takeParkedIosSim({ projectPath, slot, label, choice, out }) {
 	return null;
 }
 function clearIosAdoptionPending(projectPath, slot = "default") {
-	withConfigLock(() => {
-		const cfg = loadConfig();
+	withConfigLock$1(() => {
+		const cfg = loadConfig$1();
 		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
 		if (!cfg || !ios?.adoptionPending) return;
 		delete ios.adopted;
@@ -608,39 +419,287 @@ async function configureOwnedIosSim({ record, projectPath, slot, profile, out, r
 	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
-				};
+async function ensureIosBooted({ device, simulatorApp, timeoutMs, pollMs, out }) {
+	const udid = device?.deviceUdid;
+	if (!udid) return {
+		failed: true,
+		reason: "No iOS simulator is recorded for this project."
+	};
+	const ready = () => {
+		try {
+			getExecutor().runFile("xcrun", [
+				"simctl",
+				"spawn",
+				udid,
+				"launchctl",
+				"list"
+			], { timeoutMs: 3e4 });
+			return {
+				ok: true,
+				udid
+			};
+		} catch (error) {
+			return {
+				failed: true,
+				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
+			};
+		}
+	};
+	const booting = device?.booting;
+	if (booting?.udid === udid) {
+		try {
+			await booting.done;
+		} catch (e) {
+			return {
+				failed: true,
+				reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+			};
+		}
+		return ready();
+	}
+	let resolved;
+	try {
+		resolved = resolveOwnedIosSim(udid);
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not list simulators: ${e?.message || e}`
+		};
+	}
+	if (resolved.missing) return {
+		failed: true,
+		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
+	};
+	if (resolved.notOwned) return {
+		failed: true,
+		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
+	};
+	const sim = resolved.sim;
+	if (sim.state === "Booted") {
+		const result = ready();
+		if (result.ok && simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
+		return result;
+	}
+	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
+	const bootDeadline = Date.now() + timeoutMs;
+	try {
+		await bootIosSim(udid, {
+			timeoutMs,
+			label: sim.name,
+			out,
+			simulatorApp
+		});
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+		};
+	}
+	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
+	while (Date.now() < deadline) {
+		await sleep(pollMs);
+		let state = null;
+		try {
+			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
+		} catch {}
+		if (state === "Booted") return ready();
+	}
+	return {
+		failed: true,
+		reason: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
+	};
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#endregion
+//#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$1()?.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$1(() => {
+		const previous = deviceSlotPlatforms(loadConfig$1()?.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$1()?.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$1(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$1(() => {
+					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$1(() => {
+			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-android.ts
+const ANDROID_FRESH_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 12e4;
+const ANDROID_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 24e4;
+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,
@@ -761,7 +820,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 		systemImage: created.systemImage
 	};
 }
-function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
+function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock$1, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
 	return lock(() => {
 		const consolePort = nextConsolePort([...recordedPorts(), ...livePorts]);
 		const claim = {
@@ -792,296 +851,78 @@ async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, slot, d
 	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.`);
-		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, simulatorApp, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists } = {}) {
-	if (platform === "ios") return ensureIosBooted({
-		device,
-		simulatorApp,
-		timeoutMs: timeoutMs ?? 6e5,
-		pollMs,
-		out
-	});
-	if (platform === "android") return ensureAndroidBooted({
-		device,
-		timeoutMs: timeoutMs ?? ANDROID_BOOT_TIMEOUT_MS,
-		out,
-		logFile,
-		alive
-	});
-	return {
-		failed: true,
-		reason: `Unknown platform "${platform}".`
-	};
-}
-async function ensureIosBooted({ device, simulatorApp, timeoutMs, pollMs, out }) {
-	const udid = device?.deviceUdid;
-	if (!udid) return {
-		failed: true,
-		reason: "No iOS simulator is recorded for this project."
-	};
-	const ready = () => {
-		try {
-			getExecutor().runFile("xcrun", [
-				"simctl",
-				"spawn",
-				udid,
-				"launchctl",
-				"list"
-			], { timeoutMs: 3e4 });
-			return {
-				ok: true,
-				udid
-			};
-		} catch (error) {
-			return {
-				failed: true,
-				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
-			};
-		}
-	};
-	const booting = device?.booting;
-	if (booting?.udid === udid) {
-		try {
-			await booting.done;
-		} catch (e) {
-			return {
-				failed: true,
-				reason: `Could not boot simulator ${udid}: ${e?.message || e}`
-			};
-		}
-		return ready();
-	}
-	let resolved;
-	try {
-		resolved = resolveOwnedIosSim(udid);
-	} catch (e) {
-		return {
-			failed: true,
-			reason: `Could not list simulators: ${e?.message || e}`
-		};
-	}
-	if (resolved.missing) return {
-		failed: true,
-		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
-	};
-	if (resolved.notOwned) return {
-		failed: true,
-		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
-	};
-	const sim = resolved.sim;
-	if (sim.state === "Booted") {
-		const result = ready();
-		if (result.ok && simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
-		return result;
-	}
-	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
-	const bootDeadline = Date.now() + timeoutMs;
-	try {
-		await bootIosSim(udid, {
-			timeoutMs,
-			label: sim.name,
-			out,
-			simulatorApp
+		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
 		});
-	} catch (e) {
+		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 {
-			failed: true,
-			reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+			...claim,
+			serial
 		};
+	} catch (error) {
+		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+		throw error;
 	}
-	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();
+}
+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$1()
+		});
+	} 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: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
+		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)
 	};
 }
-async function ensureAndroidBooted({ device, timeoutMs, out, logFile = null, alive = pidExists }) {
-	if (!device?.avdName) return {
+async function ensureAndroidBooted({ device, 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."
 	};
@@ -1113,33 +954,622 @@ async function ensureAndroidBooted({ device, timeoutMs, out, logFile = null, ali
 		timeoutMs,
 		out
 	});
-	const serial = `emulator-${pickConsolePort(device.consolePort)}`;
+	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;
 	try {
-		pid = bootAndroidEmulator(device.avdName, Number(serial.replace(/^emulator-/, "")), { logFile });
+		pid = bootAndroidEmulator(device.avdName, claim.consolePort, { logFile });
 	} catch (e) {
+		releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
 		return {
 			failed: true,
 			reason: `Could not start emulator for AVD ${device.avdName}: ${e?.message || e}`
 		};
 	}
-	return waitForAndroidBoot({
+	const result = await waitForAndroidBoot({
 		serial,
 		timeoutMs,
 		pid,
 		alive,
 		out
 	});
+	if (result.failed) releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
+	return result;
 }
-function pickConsolePort(recorded) {
-	const live = liveAndroidConsolePorts();
-	if (recorded && !live.includes(Number(recorded))) return Number(recorded);
-	return nextConsolePort([...allConsolePortsAndSerials().androidConsolePorts, ...live]);
+//#endregion
+//#region src/engine/device.ts
+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
+	});
 }
-function sleep(ms) {
-	return new Promise((r) => setTimeout(r, ms));
+const BOOT_POLL_MS = 500;
+async function ensureBooted({ platform, device, simulatorApp, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists, projectPath, slot } = {}) {
+	if (platform === "ios") return ensureIosBooted({
+		device,
+		simulatorApp,
+		timeoutMs: timeoutMs ?? 6e5,
+		pollMs,
+		out
+	});
+	if (platform === "android") return ensureAndroidBooted({
+		device,
+		projectPath,
+		slot,
+		timeoutMs: timeoutMs ?? ANDROID_BOOT_TIMEOUT_MS,
+		out,
+		logFile,
+		alive
+	});
+	return {
+		failed: true,
+		reason: `Unknown platform "${platform}".`
+	};
+}
+//#endregion
+//#region src/engine/prebuild.ts
+const PREBUILD_ERROR = "STIM_PREBUILD_FAILED";
+const LAST_LINES$1 = 20;
+function nativeDirName(platform) {
+	return platform === "android" ? "android" : "ios";
+}
+function nativeDir(root, platform) {
+	return join(root, nativeDirName(platform));
+}
+function nativeDirInFingerprint(sources, platform) {
+	const dir = nativeDirName(platform);
+	return sources.some((source) => source.type === "dir" && source.filePath === dir && source.hash != null);
+}
+/**
+* @expo/fingerprint leaves a native directory out of the hash when git ignores it (CNG), so the cache
+* key only covers that directory when this workspace's recorded prebuild ran on the same fingerprint.
+*/
+function prebuildAction({ isExpo, nativeDirExists, nativeDirFingerprinted, nativeDirTracked, generatedFrom, fingerprint }) {
+	if (!isExpo) return "none";
+	if (!nativeDirExists) return "generate";
+	if (nativeDirFingerprinted || generatedFrom === fingerprint) return "none";
+	return nativeDirTracked ? "refuse" : "regenerate";
+}
+function prebuildRecord(state) {
+	const record = state?.prebuild;
+	return record && typeof record === "object" ? record : {};
+}
+function gitTracksNativeDir(root, platform) {
+	try {
+		return getExecutor().runFile("git", [
+			"-C",
+			root,
+			"ls-files",
+			"--",
+			nativeDirName(platform)
+		], { env: {
+			LC_ALL: "C",
+			LANGUAGE: "C"
+		} }).trim() !== "";
+	} catch (error) {
+		if (error?.code === "ENOENT") return false;
+		return !/not a git repository \(or any (of the parent directories|parent up to mount point)/.test(String(error?.message));
+	}
+}
+function planPrebuild(root, platform, { isExpo, fingerprint, sources }) {
+	const nativeDirExists = existsSync(nativeDir(root, platform));
+	const fingerprinted = nativeDirInFingerprint(sources, platform);
+	const generatedFrom = prebuildRecord(readWorkspaceState$1(root))[platform];
+	return prebuildAction({
+		isExpo,
+		nativeDirExists,
+		nativeDirFingerprinted: fingerprinted,
+		nativeDirTracked: nativeDirExists && !fingerprinted && gitTracksNativeDir(root, platform),
+		generatedFrom: typeof generatedFrom === "string" ? generatedFrom : null,
+		fingerprint
+	});
+}
+function recordPrebuild(root, platform, fingerprint) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		prebuild: {
+			...prebuildRecord(state),
+			[platform]: fingerprint
+		}
+	}));
+}
+function staleNativeDirRefusal(platform) {
+	const dir = nativeDirName(platform);
+	return {
+		code: PREBUILD_ERROR,
+		message: `The fingerprint leaves ${dir}/ out of the cache key, and Stim cannot show that ${dir}/ was generated from the current app config. Git tracks files in it, or could not say whether it does, so Stim will not regenerate it with \`expo prebuild --clean\`.`,
+		remedy: `Stop excluding ${dir}/ from the fingerprint (check .fingerprintignore) so the cache key covers its files, or add ${dir}/ to .gitignore and untrack it so Stim regenerates it from the app config.`
+	};
+}
+function prebuildRefusal({ isExpo, platform, nativeDirExists }) {
+	if (nativeDirExists || isExpo) return null;
+	const dir = nativeDirName(platform);
+	return {
+		code: PREBUILD_ERROR,
+		message: `This project has no ${dir}/ directory and is not an Expo (CNG) project, so Stim cannot generate one.`,
+		remedy: `Check out or generate the native project (\`npx @react-native-community/cli init\` produced one originally), or add \`expo\` to the project so \`expo prebuild\` can create ${dir}/.`
+	};
+}
+function prebuildFailure(logWriter, result) {
+	logWriter?.write?.({
+		src: "build",
+		level: "error",
+		msg: result.reason || "Expo prebuild failed.",
+		event: "prebuild_failed"
+	});
+	return result;
+}
+async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Date.now, isExpo = null, clean = false } = {}) {
+	const dirExists = existsSync(nativeDir(root, platform));
+	const refusal = prebuildRefusal({
+		isExpo: isExpo === null ? detectIsExpo(root) : isExpo,
+		platform,
+		nativeDirExists: dirExists
+	});
+	if (refusal) return prebuildFailure(logWriter, {
+		failed: true,
+		code: refusal.code,
+		reason: refusal.message,
+		remedy: refusal.remedy,
+		error: refusal,
+		lastLines: []
+	});
+	const bin = expoBinPath(root);
+	if (!bin) {
+		const binRefusal = expoBinRefusal(root, "prebuild");
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: binRefusal.message,
+			remedy: binRefusal.remedy,
+			lastLines: []
+		});
+	}
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const startedAt = now();
+	const tail = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		tail.push(msg);
+		if (tail.length > LAST_LINES$1) tail.shift();
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "prebuild"
+		});
+	};
+	let child;
+	try {
+		child = spawnDeclared(() => spawn(bin, [
+			"prebuild",
+			"-p",
+			platform,
+			"--no-install",
+			...clean ? ["--clean"] : []
+		], {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				FORCE_COLOR: "0",
+				CI: "1"
+			}
+		}));
+	} catch (err) {
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `Could not run \`expo prebuild\`: ${err?.message || err}`,
+			lastLines: []
+		});
+	}
+	const outReader = createLineReader(push);
+	const errReader = createLineReader(push);
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => outReader.push(chunk));
+	child.stderr?.on("data", (chunk) => errReader.push(chunk));
+	const result = await waitForChild(child);
+	outReader.flush();
+	errReader.flush();
+	const durationMs = now() - startedAt;
+	if (result.error) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `Could not run \`expo prebuild\`: ${result.error?.message || result.error}`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	if (result.code !== 0) {
+		const how = result.signal ? `signal ${result.signal}` : `exit code ${result.code}`;
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `\`expo prebuild -p ${platform}\` failed (${how}).`,
+			lastLines: tail.slice(),
+			durationMs
+		});
+	}
+	if (!existsSync(nativeDir(root, platform))) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `\`expo prebuild -p ${platform}\` succeeded but did not create ${nativeDirName(platform)}/.`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	return {
+		ok: true,
+		durationMs,
+		nativeDir: nativeDir(root, platform)
+	};
+}
+//#endregion
+//#region src/engine/js-swap.ts
+const JS_BUNDLE_NAME = "main.jsbundle";
+const LAST_LINES = 5;
+function hermesEnabledFromProperties(text) {
+	if (typeof text !== "string") return true;
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		return true;
+	}
+	if (!data || typeof data !== "object") return true;
+	const raw = data.hermesEnabled;
+	return raw !== "false" && raw !== false;
+}
+function readHermesEnabled(root) {
+	try {
+		return hermesEnabledFromProperties(readFileSync(join(root, "ios", "Podfile.properties.json"), "utf-8"));
+	} catch {
+		return true;
+	}
+}
+const ENTRY_CANDIDATES = [
+	"index.js",
+	"index.ts",
+	"index.tsx",
+	"index.jsx"
+];
+function pickEntryFile(entries) {
+	const names = new Set((Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string"));
+	return ENTRY_CANDIDATES.find((c) => names.has(c)) ?? "index.js";
+}
+function detectEntryFile(root) {
+	let entries;
+	try {
+		entries = readdirSync(root);
+	} catch {
+		return "index.js";
+	}
+	return pickEntryFile(entries);
+}
+function bundleCommand({ isExpo, entryFile, bundleOutput, assetsDest }) {
+	if (isExpo) return {
+		file: "npx",
+		args: [
+			"expo",
+			"export:embed",
+			"--platform",
+			"ios",
+			"--dev",
+			"false",
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest
+		]
+	};
+	return {
+		file: "npx",
+		args: [
+			"react-native",
+			"bundle",
+			"--platform",
+			"ios",
+			"--dev",
+			"false",
+			"--entry-file",
+			entryFile,
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest
+		]
+	};
+}
+function hermescPath(root, { exists = existsSync } = {}) {
+	const candidates = [
+		join(root, "node_modules", "hermes-compiler", "hermesc", "osx-bin", "hermesc"),
+		join(root, "ios", "Pods", "hermes-engine", "destroot", "bin", "hermesc"),
+		join(root, "node_modules", "react-native", "sdks", "hermesc", "osx-bin", "hermesc")
+	];
+	return candidates.find(exists) ?? candidates[candidates.length - 1];
+}
+function hermescArgs({ bundle, out }) {
+	return [
+		"-emit-binary",
+		"-out",
+		out,
+		bundle
+	];
+}
+async function swapJsBundle({ root, isExpo, cachedAppPath, logWriter = null, exec = null, spawnFn = null, mkdtemp = () => makeTemporaryDirectory(cachedAppPath, "stim-js-swap-"), exists = existsSync, hermesEnabled = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, onHeartbeat = (line) => console.error(line) }) {
+	const e = exec || getExecutor();
+	const startedAt = now();
+	const elapsed = () => now() - startedAt;
+	let tmp;
+	const fail = (step, reason, lastLines = []) => {
+		logWriter?.write?.({
+			src: "build",
+			level: "error",
+			msg: `JS swap failed at ${step}: ${reason}`,
+			event: "js_swap"
+		});
+		if (tmp) removeTemporaryEntry(tmp);
+		return {
+			failed: true,
+			step,
+			reason,
+			lastLines,
+			durationMs: elapsed()
+		};
+	};
+	let appCopy;
+	try {
+		tmp = mkdtemp();
+		appCopy = join(tmp, basename(cachedAppPath));
+		try {
+			e.runFile("cp", [
+				"-c",
+				"-R",
+				cachedAppPath,
+				appCopy
+			]);
+		} catch {
+			removeTemporaryEntry(appCopy);
+			e.runFile("cp", [
+				"-R",
+				cachedAppPath,
+				appCopy
+			]);
+		}
+	} catch (err) {
+		return fail("copy", `could not copy ${cachedAppPath} aside: ${describe(err)}`);
+	}
+	const bundleOutput = join(tmp, JS_BUNDLE_NAME);
+	const assetsDest = join(tmp, "assets");
+	const command = bundleCommand({
+		isExpo,
+		entryFile: isExpo ? "index.js" : detectEntryFile(root),
+		bundleOutput,
+		assetsDest
+	});
+	try {
+		mkdirSync(assetsDest, { recursive: true });
+	} catch (err) {
+		return fail("bundle", `could not create ${assetsDest}: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `${command.file} ${command.args.join(" ")}`,
+		event: "js_swap"
+	});
+	const spawn = spawnFn || ((cmd, args, opts) => e.spawn(cmd, args, opts));
+	const transcript = [];
+	const push = (line) => {
+		const msg = cleanLine(line);
+		if (msg.trim() === "") return;
+		transcript.push(msg);
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "js_swap"
+		});
+	};
+	let child;
+	try {
+		child = spawn(command.file, command.args, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				FORCE_COLOR: "0"
+			}
+		});
+	} catch (err) {
+		return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(err)}`);
+	}
+	const reader = {
+		out: createLineReader(push),
+		err: createLineReader(push)
+	};
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => reader.out.push(chunk));
+	child.stderr?.on("data", (chunk) => reader.err.push(chunk));
+	const stopHeartbeat = startBuildHeartbeat({
+		intervalMs: heartbeatMs,
+		elapsed,
+		emit: onHeartbeat,
+		label: "swap"
+	});
+	let outcome;
+	try {
+		outcome = await waitForChild(child);
+	} finally {
+		stopHeartbeat();
+	}
+	reader.out.flush();
+	reader.err.flush();
+	if (outcome.error) return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(outcome.error)}`);
+	if (outcome.code !== 0) {
+		const how = outcome.signal ? `signal ${outcome.signal}` : `exit code ${outcome.code}`;
+		return fail("bundle", `\`${command.args.slice(0, 2).join(" ")}\` failed (${how})`, tailLines(transcript, LAST_LINES));
+	}
+	if (!exists(bundleOutput)) return fail("bundle", `the bundle command exited 0 but wrote no ${JS_BUNDLE_NAME} at ${bundleOutput}`);
+	let hermes = false;
+	let note;
+	if (hermesEnabled ?? readHermesEnabled(root)) {
+		const hermesc = hermescPath(root);
+		if (!exists(hermesc)) note = `hermesc not found at ${hermesc}; embedding the plain JS bundle instead of Hermes bytecode`;
+		else {
+			const hbc = join(tmp, `${JS_BUNDLE_NAME}.hbc`);
+			try {
+				e.runFile(hermesc, hermescArgs({
+					bundle: bundleOutput,
+					out: hbc
+				}));
+				e.runFile("mv", [hbc, bundleOutput]);
+				hermes = true;
+			} catch (err) {
+				return fail("hermesc", `hermesc failed on ${bundleOutput}: ${describe(err)}`);
+			}
+		}
+	}
+	try {
+		e.runFile("cp", [bundleOutput, join(appCopy, JS_BUNDLE_NAME)]);
+		e.runFile("cp", [
+			"-R",
+			`${assetsDest}/.`,
+			`${appCopy}/`
+		]);
+	} catch (err) {
+		return fail("replace", `could not replace the JS bundle inside ${appCopy}: ${describe(err)}`);
+	}
+	try {
+		e.runFile("codesign", [
+			"--force",
+			"--sign",
+			"-",
+			appCopy
+		]);
+	} catch (err) {
+		return fail("codesign", `codesign --force --sign - ${appCopy} failed: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `JS swap done: ${hermes ? "hermes bytecode" : "plain JS"} into ${appCopy} in ${elapsed()}ms`,
+		event: "js_swap"
+	});
+	const result = {
+		ok: true,
+		appPath: appCopy,
+		tmpDir: tmp,
+		hermes,
+		durationMs: elapsed()
+	};
+	if (note) result.note = note;
+	return result;
+}
+function describe(err) {
+	return String(err?.message || err);
+}
+//#endregion
+//#region src/commands/dev-client.ts
+function devClientScheme(root, appPath = null, { exec = null } = {}) {
+	if (!hasDevClient(root)) return void 0;
+	const fromBundle = pickDevClientScheme(readBundleSchemes(appPath, { exec }));
+	if (fromBundle) return fromBundle;
+	const app = readJsonObject(join(root, "app.json"));
+	const expo = app?.expo;
+	const raw = (isJsonObject(expo) ? expo.scheme : void 0) ?? app?.scheme ?? null;
+	const scheme = Array.isArray(raw) ? raw.find((s) => typeof s === "string" && s.trim() !== "") : raw;
+	if (typeof scheme !== "string" || scheme.trim() === "") return void 0;
+	return scheme.trim();
+}
+function schemesFromInfoPlist(plist) {
+	const types = plist?.CFBundleURLTypes;
+	if (!Array.isArray(types)) return [];
+	const out = [];
+	for (const type of types) {
+		const schemes = type?.CFBundleURLSchemes;
+		if (Array.isArray(schemes)) out.push(...schemes.filter((s) => typeof s === "string" && s.trim() !== ""));
+	}
+	return out;
+}
+function readBundleSchemes(appPath, { exec = null } = {}) {
+	if (typeof appPath !== "string" || appPath.trim() === "") return [];
+	const e = exec || getExecutor();
+	let out;
+	try {
+		out = e.runFile("plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			join(appPath, "Info.plist")
+		]);
+	} catch {
+		return [];
+	}
+	try {
+		return schemesFromInfoPlist(JSON.parse(String(out)));
+	} catch {
+		return [];
+	}
+}
+const THIRD_PARTY_SCHEME = /^(?:fb\d+|com\.googleusercontent\.apps\.|msauth\.|msauthv2|twitterkit-|db-[a-z0-9]+$|spotify|snapchat|com\.facebook)/i;
+function pickDevClientScheme(schemes) {
+	const all = (Array.isArray(schemes) ? schemes : []).filter((s) => typeof s === "string" && s.trim() !== "").map((s) => s.trim()).filter((s) => !/^(?:https?|mailto|tel|sms|itms(?:-apps)?)$/i.test(s));
+	const expo = all.filter((s) => s.startsWith("exp+"));
+	return (expo.length ? expo : all.filter((s) => !THIRD_PARTY_SCHEME.test(s))).toSorted((a, b) => b.length - a.length)[0] ?? null;
+}
+function hasDevClient(root) {
+	const pkg = readJsonObject(join(root, "package.json"));
+	if ([pkg?.dependencies, pkg?.devDependencies].some((deps) => isJsonObject(deps) && "expo-dev-client" in deps)) return true;
+	return isPackageResolvable(root, "expo-dev-client");
 }
 //#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 };
+export { isPhysicalDeviceRequest as _, swapJsBundle as a, warmMetro as b, runPrebuild as c, ensureOwnedDevice as d, AvdBootError as f, ensureWorkspaceStorageSafely as g, ensureDevServer as h, detectEntryFile as i, staleNativeDirRefusal as l, clearIosAdoptionPending as m, pickDevClientScheme as n, planPrebuild as o, AvdRecoveryError as p, schemesFromInfoPlist as r, recordPrebuild as s, devClientScheme as t, ensureBooted as u, launchOutcomeRecord as v, sleep$1 as y };