stim 1.8.0 → 1.9.0

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

@@ -1,318 +1,330 @@
-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 { K as projectDeviceSlots, N as readJsonObject, O as acquireAvdClaim, S as setDevice, T as withConfigLock, U as deviceSlotPlatforms, g as loadConfig, i as clearDevice, j as isJsonObject, k as ownership_claim_exports, t as allConsolePortsAndSerials, u as getConfigDir, v as releaseAndroidConsolePort, x as saveConfig } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { u as ensureWorkspaceStorage, v as workspaceId } from "./workspace-state-DF2gCFhx.mjs";
+import { E as removeTemporaryEntry, T as makeTemporaryDirectory } from "./worktree-R_cUlE7s.mjs";
+import { a as detectIsExpo, c as ownedDeviceLabel, s as isPackageResolvable } from "./project-DS112DYB.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as pidExists, t as NOT_OURS_FOREIGN_CWD } from "./metro-DrLHaMn2.mjs";
+import { _ as iosSimSlimProfileSetting, a as androidAvdConfigSetting, c as androidDataPartitionSizeGbSetting } from "./settings-D030k0t4.mjs";
+import { A as ownedAvdMatchesConfiguration, C as listAdbDevices, F as pickDefaultSystemImage, H as waitForBoot, N as ownedAvdSystemImage, O as nextConsolePort, R as resolveOwnedAvdSerial, T as listInstalledSystemImages, d as avdPoolConfiguration, h as createOwnedAvd, j as ownedAvdName, l as assertOwnedAvdStopped, m as configureNewOwnedAvd, p as bootAndroidEmulator, w as listAvds, x as getAvdNameForSerial } from "./android-_y4Ohi5z.mjs";
+import { l as phaseLine } from "./command-output-gByVmIjy.mjs";
+import { r as releaseBuildLock, t as acquireBuildLock } from "./build-lock-DPXPLgTc.mjs";
+import { n as spawnDeclared } from "./spawn-claims-Dn3C_N6w.mjs";
+import { i as expoBinRefusal, r as expoBinPath, t as cleanLine } from "./server-expo-B_lctBR3.mjs";
+import { b as resolveEasCliBin, i as isLegacyDeletionClaim, l as selectParked, n as adoptParked, o as parkedMaxSetting, r as dropParked, s as readParked } from "./sim-pool-KaIsp2Ft.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-Q_OtW1Rf.mjs";
+import { A as readHostMemoryPressure, C as resolveOwnedIosSim, D as configuredIosSimulatorViewer, S as resolveIosCreation, _ as parseRuntimeVersion, b as resetIosKeychain, f as listIosDeviceTypes, h as ownedSimName, i as createOwnedIosSim, k as hostMemoryPressureAdvice, l as iosSimulatorFailureAdvice, n as bootIosSim, u as listAllIosSims, x as resetIosPrivacy, y as renameIosSim } from "./ios-BL2NFckr.mjs";
+import { d as startBuildHeartbeat, f as tailLines, n as HEARTBEAT_INTERVAL_MS } from "./xcode-BZqyxh3e.mjs";
+import { a as liveOwnedDeviceCount, i as deviceTypeMismatch, t as reconcileSimSlim } from "./simslim-B_LsGLuJ.mjs";
+import { D as teardownParkedAvd, O as teardownParkedIosSim, T as teardownOwnedAvd } from "./device-remote-AQ5rQPqr.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+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 { createHash, randomUUID } from "node:crypto";
 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}`);
-	}
+import { request } from "node:http";
+//#region src/engine/eas-build.ts
+function isEasBuildFailure(result) {
+	return result?.ok === false;
+}
+function easOptionRefusal({ profile, isExpo, buildSelector, buildCache }) {
+	if (profile === void 0) return null;
+	if (profile.trim() && isExpo && buildSelector === void 0 && buildCache !== false) return null;
 	return {
-		managed: Boolean(profile),
-		profile: profile ?? null
+		code: "STIM_BAD_ARG",
+		message: "--eas-profile requires an Expo project and a non-empty development profile.",
+		remedy: "Use --eas-profile <name> without --scheme, --configuration, --variant, or --no-build-cache."
 	};
 }
-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 object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function simslimIsOnPath() {
-	try {
-		return Boolean(getExecutor().findExecutable("simslim"));
-	} catch {
-		return false;
-	}
+function shellArg(value) {
+	return /^[a-zA-Z0-9_.-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
-//#endregion
-//#region src/engine/android-avd-setup.ts
-var AvdBootError = class extends Error {
+function easDeviceBuildRemedy(profile) {
+	return `If the device is not registered, run npx eas-cli device:create. With approval for cloud build costs and signing changes, run npx eas-cli build --platform ios --profile ${shellArg(profile)} to produce a build with a valid profile for this device, then retry the same Stim command.`;
+}
+var EasFailure = class extends Error {
+	code;
 	remedy;
-	constructor(message, remedy, cause) {
-		super(message, { cause });
+	constructor(code, message, remedy) {
+		super(message);
+		this.code = code;
 		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;
+function selectEasBuild(builds, { platform, profile, fingerprint, projectId, physical = false }) {
+	if (!Array.isArray(builds)) throw new Error("EAS build:list did not return an array.");
+	for (const value of builds) {
+		const build = object(value);
+		if (typeof build.id === "string" && build.id.length > 0 && build.status === "FINISHED" && build.platform === platform.toUpperCase() && build.buildProfile === profile && object(build.fingerprint).hash === fingerprint && (object(build.app).id ?? object(build.project).id) === projectId && (platform !== "ios" || build.isForIosSimulator === !physical) && build.distribution === "INTERNAL" && typeof object(build.artifacts).applicationArchiveUrl === "string") return build.id;
+	}
 	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;
-		}
+async function resolveEasDevelopmentBuild({ root, platform, profile, note, isExpo = true, physical = false, selectors = [], buildCache }) {
+	if (profile === void 0) return null;
+	const refusal = easOptionRefusal({
+		profile,
+		isExpo,
+		buildSelector: selectors.find((value) => value != null) ?? void 0,
+		buildCache
 	});
-	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.`);
-		}
+	if (refusal) return {
+		ok: false,
+		...refusal
 	};
-	let prepared;
-	let child;
-	const creationRunning = () => child?.pid !== void 0 && processGroupAlive(child.pid);
-	let configurationFailure;
+	const retry = "the same Stim command";
+	const buildCommand = `npx eas-cli build --platform ${platform} --profile ${shellArg(profile)}`;
+	let lock = null;
 	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;
+		const cli = resolveEasCliBin(root);
+		if (!cli) throw new EasFailure("STIM_EAS_UNAVAILABLE", "EAS CLI is not installed.", "Install eas-cli, run eas login, then retry.");
+		let profileEnv = {};
+		const run = (args, timeoutMs = 12e4) => {
 			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);
+				return JSON.parse(getExecutor().runFile(cli.file, [
+					...args,
+					"--json",
+					"--non-interactive"
+				], {
+					cwd: root,
+					timeoutMs,
+					env: profileEnv
+				}));
+			} catch {
+				throw new EasFailure("STIM_EAS_UNAVAILABLE", `EAS ${args[0]} failed or returned invalid JSON.`, `Run npx eas-cli ${args.map(shellArg).join(" ")} to inspect the error, then retry ${retry}.`);
 			}
-		}
-		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);
+		};
+		note(`eas   resolving profile ${profile}`);
+		const config = object(run([
+			"config",
+			"--platform",
+			platform,
+			"--profile",
+			profile
+		]));
+		const buildProfile = object(config.buildProfile);
+		profileEnv = object(buildProfile.env);
+		const projectId = object(object(object(config.appConfig).extra).eas).projectId;
+		if (buildProfile.developmentClient !== true || buildProfile.distribution !== "internal" || platform === "ios" && buildProfile.simulator === true !== !physical) throw new EasFailure("STIM_BAD_ARG", `EAS profile ${profile} is not an internal development build for this ${platform} target.`, `Set developmentClient: true and distribution: internal${platform === "ios" ? `, with ios.simulator: ${!physical}` : ""} in that eas.json profile.`);
+		if (typeof projectId !== "string" || !projectId) throw new EasFailure("STIM_BAD_ARG", "The Expo app is not linked to an EAS project.", "Link the intended EAS project with eas init, then retry.");
+		if (platform === "ios" ? buildProfile.buildConfiguration !== void 0 && buildProfile.buildConfiguration !== "Debug" : buildProfile.gradleCommand !== void 0 && (typeof buildProfile.gradleCommand !== "string" || !/^:app:assemble\w*Debug$/.test(buildProfile.gradleCommand))) throw new EasFailure("STIM_BAD_ARG", `EAS profile ${profile} overrides the development build configuration.`, "Use ios.buildConfiguration: Debug or an android.gradleCommand that assembles a single Debug APK, or remove the override.");
+		note(`eas   fingerprinting ${platform} with profile ${profile}`);
+		const fingerprint = object(run([
+			"fingerprint:generate",
+			"--platform",
+			platform,
+			"--build-profile",
+			profile
+		])).hash;
+		if (typeof fingerprint !== "string" || !/^[a-f0-9]{40,64}$/.test(fingerprint)) throw new EasFailure("STIM_EAS_UNAVAILABLE", "EAS returned no valid native fingerprint.", `Run npx eas-cli fingerprint:generate --platform ${platform} --build-profile ${shellArg(profile)} to inspect the result.`);
+		note(`eas   looking for ${fingerprint.slice(0, 8)}`);
+		const buildId = selectEasBuild(run([
+			"build:list",
+			"--platform",
+			platform,
+			"--build-profile",
+			profile,
+			"--fingerprint-hash",
+			fingerprint,
+			"--status",
+			"finished",
+			...platform === "ios" && !physical ? ["--simulator"] : ["--distribution", "internal"],
+			"--limit",
+			"1"
+		]), {
+			platform,
+			profile,
+			fingerprint,
+			projectId,
+			physical
 		});
+		if (!buildId) throw new EasFailure("STIM_EAS_BUILD_MISSING", `No compatible EAS ${platform} build exists for profile ${profile} and fingerprint ${fingerprint}.`, `A cloud build may incur charges. With approval to run it, use ${buildCommand}, then retry ${retry}.`);
+		const cacheKey = `eas-${createHash("sha256").update(JSON.stringify({
+			projectId,
+			buildId
+		})).digest("hex")}-debug-${physical && platform === "ios" ? "device" : "sim"}`;
+		lock = acquireBuildLock({
+			platform,
+			key: cacheKey,
+			root
+		});
+		if (!lock.acquired) throw new EasFailure("STIM_EAS_UNAVAILABLE", `Another run holds the EAS artifact claim at ${lock.path}.`, `Wait for that run to finish, then retry ${retry}.`);
+		note(`eas   resolving artifact for build ${buildId}`);
+		const result = object(run([
+			"build:download",
+			"--build-id",
+			buildId
+		], 6e5));
+		if (typeof result.path !== "string" || !existsSync(result.path)) throw new Error("EAS returned no downloaded artifact.");
+		const path = realpathSync(result.path);
+		if (platform === "ios" ? !path.endsWith(".app") || !statSync(path).isDirectory() : !path.endsWith(".apk") || !statSync(path).isFile()) throw new Error("EAS returned an unexpected artifact path or type.");
+		note(`eas   artifact ready ${fingerprint.slice(0, 8)}`);
+		return {
+			ok: true,
+			path,
+			fingerprint,
+			cacheKey,
+			cacheHit: "remote"
+		};
+	} catch (error) {
+		const claim = (0, ownership_claim_exports.claimFailure)(error, null);
+		if (claim) return {
+			ok: false,
+			code: claim.code,
+			message: claim.message,
+			remedy: claim.remedy
+		};
+		if (error instanceof EasFailure) return {
+			ok: false,
+			code: error.code,
+			message: error.message,
+			remedy: error.remedy
+		};
+		return {
+			ok: false,
+			code: "STIM_EAS_UNAVAILABLE",
+			message: `Could not resolve the EAS development build: ${error.message}`,
+			remedy: `Retry ${retry}. No cloud build was started.`
+		};
 	} finally {
-		if (!creationRunning()) releaseClaim(claim);
-		else {
-			child?.stdout?.destroy();
-			child?.stderr?.destroy();
-			child?.unref();
-		}
+		releaseBuildLock(lock);
 	}
-	if (configurationFailure) {
-		const { error } = configurationFailure;
-		const cleanup = teardown(avdName, {
-			del: true,
-			owner: {
-				projectPath,
-				slot,
-				expectedRecord: reservation
-			},
-			onRemoved: () => {
-				clearDevice(projectPath, "android", slot, avdName);
-			}
+}
+//#endregion
+//#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);
 		});
-		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 });
+		req.on("response", (res) => {
+			let body = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => {
+				if (!prefetch) body += chunk;
+			});
+			res.on("error", () => resolve(null));
+			res.on("end", () => resolve(res.statusCode === 200 ? body : null));
+		});
+		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;
+		}
+		if (bundleUrl) {
+			const bundle = new URL(bundleUrl, origin);
+			url.pathname = bundle.pathname;
+			url.search = bundle.search;
+		}
+		await requestLocal(url, platform, true);
+	} catch {}
+}
+//#endregion
+//#region src/commands/native-runtime.ts
+const sleep$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+const GATE_RETRY_DELAYS_MS = [
+	3e3,
+	7e3,
+	1e4
+];
+function gateShouldRetry(resolution) {
+	if (resolution?.metro) return false;
+	return resolution?.kind !== NOT_OURS_FOREIGN_CWD;
+}
+async function resolveMetroWithRetry(resolve, port, root, { delays = GATE_RETRY_DELAYS_MS, sleep: wait = sleep$1, onRetry = (_info) => {} } = {}) {
+	let resolution = await resolve(port, root);
+	for (let i = 0; i < delays.length && gateShouldRetry(resolution); i++) {
+		const delayMs = delays[i];
+		if (delayMs === void 0) break;
+		onRetry({
+			attempt: i + 1,
+			delayMs,
+			resolution
+		});
+		await wait(delayMs);
+		resolution = await resolve(port, root);
 	}
-	return prepared;
+	return resolution;
+}
+function noMetroMessage({ port, resolution, supervisor, supervisorAlive }) {
+	const foreign = resolution?.notOurs;
+	if (supervisor && supervisor.port === port && supervisorAlive) {
+		const mode = supervisor.mode ? `${supervisor.mode} ` : "";
+		return `A supervisor record exists for port ${port} (pid ${supervisor.pid}, ${mode}dev server) but it did not verify as this workspace's Metro${foreign ? `: ${foreign}` : " -- nothing answered /status"}. Metro may still be indexing this project (a monorepo file-map crawl blocks its event loop for ~20s after the port opens).`;
+	}
+	if (foreign) return `Port ${port} is in use but is NOT this workspace's dev server: ${foreign}.`;
+	return `Nothing is serving this workspace's dev server on port ${port}.`;
+}
+function noMetroRemedy({ port, supervisor, supervisorAlive }) {
+	if (supervisor && supervisor.port === port && supervisorAlive) return "Re-run `stim ios` in a few seconds, or give the dev server longer to verify with `stim start --wait <seconds>`.";
+	return "Run `stim start` first, or pass --no-metro-check.";
+}
+async function ensureWorkspaceStorageSafely(root, { note = (_line) => {} } = {}) {
+	try {
+		return ensureWorkspaceStorage(root);
+	} catch (err) {
+		note(chalk.dim(`Could not prepare this workspace's Stim state: ${err?.message || err}`));
+		throw err;
+	}
+}
+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
+	};
+}
+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 +340,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)));
@@ -608,26 +589,274 @@ 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) {
+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()?.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-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.`));
@@ -786,302 +1015,84 @@ async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, slot, d
 		slot,
 		avdName,
 		deviceName,
-		livePorts: liveAndroidConsolePorts(),
-		metadata
-	});
-	const serial = `emulator-${claim.consolePort}`;
-	try {
-		reportAndroidMemoryPressure(out);
-		const pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
-		out(chalk.dim(phaseLine("device", `waiting for ${serial} to finish booting`)));
-		const result = await waitForAndroidBoot({
-			serial,
-			timeoutMs: ANDROID_FRESH_BOOT_TIMEOUT_MS,
-			pid,
-			alive,
-			out
-		});
-		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;
+		livePorts: liveAndroidConsolePorts(),
+		metadata
+	});
+	const serial = `emulator-${claim.consolePort}`;
 	try {
-		await bootIosSim(udid, {
-			timeoutMs,
-			label: sim.name,
-			out,
-			simulatorApp
+		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
 		});
-	} 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()
+		});
+	} 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 +1124,565 @@ 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 shouldPrebuild({ isExpo, nativeDirExists }) {
+	return Boolean(isExpo) && !nativeDirExists;
+}
+function needsPrebuild(root, platform, isExpo) {
+	return shouldPrebuild({
+		isExpo,
+		nativeDirExists: existsSync(nativeDir(root, platform))
+	});
+}
+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 } = {}) {
+	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"
+		], {
+			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 { isEasBuildFailure as C, easDeviceBuildRemedy as S, noMetroMessage as _, swapJsBundle as a, sleep$1 as b, ensureBooted as c, AvdRecoveryError as d, clearIosAdoptionPending as f, launchOutcomeRecord as g, isPhysicalDeviceRequest as h, detectEntryFile as i, ensureOwnedDevice as l, gateShouldRetry as m, pickDevClientScheme as n, needsPrebuild as o, ensureWorkspaceStorageSafely as p, schemesFromInfoPlist as r, runPrebuild as s, devClientScheme as t, AvdBootError as u, noMetroRemedy as v, resolveEasDevelopmentBuild as w, warmMetro as x, resolveMetroWithRetry as y };