stim 1.0.0 → 1.1.0

package/dist/android-DnZlT3aU.mjs

@@ -0,0 +1,2279 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { C as withConfigLock, S as upsertProject, f as getProject, g as loadConfig, l as getConcurrencyLimits, y as saveConfig } from "./config-D7uu8Gbq.mjs";
+import { r as createNdjsonWriter } from "./ndjson-DcAtEx_K.mjs";
+import { D as workspaceLogsDir, T as workspaceDir, _ as writeWorkspaceState, g as writeWorkspaceLaunch, n as MODE_EXPO, p as readWorkspaceState, t as MODE_BARE, v as emulatorLogFile } from "./state-IYEY-zi8.mjs";
+import { C as removeTemporaryEntry, S as makeTemporaryDirectory, g as repoRoot, s as gitCommonDir } from "./worktree-Dx3ZC5lS.mjs";
+import { a as findProjectRoot, c as projectShortcut, i as detectIsExpo, n as detectAndroidPackage, r as detectBundleId, t as appProjectProblem } from "./project-COj6nzzh.mjs";
+import { r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { i as resolveProjectMetro, r as pidExists } from "./metro-B01H3EuD.mjs";
+import { n as verifyCollectorOwnership, r as readCollectors } from "./ownership-D8HmSv2E.mjs";
+import { a as easAuthNote, c as loadProjectProvider, d as resolveEasCliBin, f as resolveRemote, i as checkEasAuth, n as UPLOAD_TIMEOUT_MS, o as exitAfterFlush, p as uploadRemote, r as cacheLevel, s as isEasAuthFailureText, t as RESOLVE_TIMEOUT_MS, x as parkedMaxSetting } from "./remote-cache-DOi5-zLj.mjs";
+import { A as settingFile, B as compilerCacheFallbackMessage, E as remoteDeviceSettingError, F as unknownSettingKeys, H as resolveOptimizations, L as detectProviders, M as settingShapeErrors, O as resolveCacheProviderConfig, P as tunnelModeSetting, T as remoteAndroidSetting, V as optimizationBuildProfile, a as SETTING_SHAPE_REMEDY, d as cacheProviderSettingError, k as resolveSettings, r as REMOTE_DEVICE_BACKENDS, s as androidAvdConfigSettingError, u as androidDataPartitionSizeGbSettingError, w as publicUrlSetting, z as artifactCachePolicy } from "./settings-BSwrY4FZ.mjs";
+import { _ as launchErrorPreview, c as launchErrorReport, g as stepTimer, h as stepClock, i as formatDuration, l as phaseLine, n as appReadinessMessage, p as shortHash } from "./command-output-8wHMEde0.mjs";
+import { D as verifyAndroidReleaseLaunch, E as unverifiedLaunchLines, O as verifyLaunch, S as launchAndroidReleaseApp, _ as installConflictKind, c as RELEASE_VERIFY_WAIT_MS, d as androidDevClientUrl, g as installAndroidApp, h as deviceShellArg, i as LAUNCH_BUNDLING, n as DEFAULT_METRO_PORT, o as LAUNCH_FATAL, s as LAUNCH_UNVERIFIED, t as ADB_INSTALL_TIMEOUT_MS, u as androidAppProcess, x as launchAndroidApp } from "./app-install-oZIQRbdD.mjs";
+import { C as untrackedNativeFiles, D as readAssetManifest, E as compareAssetManifests, S as untrackedMissLine, T as captureAssetManifest, _ as providerUploadOutcome, b as storeBuild, c as buildCacheKey, d as filesystemBuildCapability, f as fingerprintDiffRecord, g as providerDownloadPath, h as prepareProviderDownloadDir, i as releaseBuildLock, l as describeFingerprintMiss, m as fingerprintProject, n as acquireBuildLock, o as takeoverLine, p as fingerprintDiffSuffix, s as waitForBuild, t as WAIT_CEILING_MS, v as refingerprintAfterMutation, w as assetDiffReason, x as storedAssetManifest, y as resolveBuild } from "./build-lock-vE45ZzJZ.mjs";
+import { r as claimFailure } from "./ownership-claim-CeJLEpjD.mjs";
+import { a as lostLine, c as releaseLeaseOnSignal, i as leaseExpiryText, l as runLease, n as DEBUG_VERIFY_STEP_MS, o as lostRefusal, r as acquireRunLease, s as parseDeviceWait, t as selectFromPool, u as waitFlagConflict } from "./device-pool-BlHXnYYs.mjs";
+import { r as releaseBuildSlot, t as acquireBuildSlot } from "./build-slots-CgacA9zQ.mjs";
+import { c as ensureWorkspaceStorageSafely, d as noMetroMessage, f as noMetroRemedy, i as detectEntryFile, n as pickDevClientScheme, o as needsPrebuild, p as resolveMetroWithRetry, s as runPrebuild, t as devClientScheme, u as launchOutcomeRecord } from "./dev-client-Bvky1hya.mjs";
+import { a as statsProjectKey, i as recordRunStats, n as readRunEstimates, t as createRunRecorder } from "./stats-wqxPm7Tv.mjs";
+import { E as physicalDeviceModel, O as probeEmulatorSerial, _ as listAdbDevices, a as androidSystemImageAbi, b as memoizeEmulatorProbe, f as emulatorDiskSpaceRemedy, h as findBuildTool, i as androidPoolNoCandidatesRefusal, j as resolvePhysicalDevice, k as resetAdoptedAvd, m as extractEmulatorFailure, n as androidHome, p as emulatorFailureRemedy, r as androidPoolCandidates, t as androidDeviceAbi, y as listInstalledSystemImages } from "./android-xmyGBNy5.mjs";
+import { S as unknownAndroidSystemImageRefusal, _ as checkDeviceCapacity, b as ensureOwnedDevice, f as startBuildHeartbeat, p as tailLines, r as HEARTBEAT_INTERVAL_MS, y as ensureBooted } from "./xcode-CDB6fytw.mjs";
+import { a as ensureMetroReachable, b as ownedSessionName, l as resolveRemoteContext, n as binOnPath, o as ensureRemoteBootOwned, s as remoteAndroidDeps } from "./device-remote-CCgkG82J.mjs";
+import { t as cleanLine } from "./server-expo-BEMr_m6p.mjs";
+import { a as buildAndroid, c as CCACHE_NOT_RUN, f as resolveCcache, l as CCACHE_UNAVAILABLE, n as resolveAndroidCas, o as productFlavorRefusal, p as formatDiagnostic, r as resolveAndroidCompilerCache, s as readProductFlavors, u as ccacheActivityLine } from "./android-cas-DGlTStWu.mjs";
+import { t as spawnEntry } from "./spawn-entry-nCE6m770.mjs";
+import { a as printNativeCrashReport, r as captureNativeCrashes, t as errorDiagnostics } from "./error-diagnostics-B5IJwv3-.mjs";
+import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { InvalidArgumentError } from "commander";
+import { basename, dirname, join, relative } from "node:path";
+import chalk from "chalk";
+import { createWarnOnce, loadCacheProvider, resolveTieredBuild, storeTieredBuild } from "@stim-cli/cache";
+//#region src/engine/apk-swap.ts
+const ANDROID_BUNDLE_NAME = "index.android.bundle";
+const ANDROID_BUNDLE_ENTRY = `assets/${ANDROID_BUNDLE_NAME}`;
+const LAST_LINES = 5;
+function hermesEnabledFromGradleProperties(text) {
+	if (typeof text !== "string") return true;
+	let value = null;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "" || line.startsWith("#") || line.startsWith("!")) continue;
+		const match = /^hermesEnabled\s*[=:]\s*(.*)$/.exec(line);
+		if (match) value = match[1].trim();
+	}
+	return value === null || value.toLowerCase() !== "false";
+}
+function readAndroidHermesEnabled(root) {
+	try {
+		return hermesEnabledFromGradleProperties(readFileSync(join(root, "android", "gradle.properties"), "utf-8"));
+	} catch {
+		return true;
+	}
+}
+function hermescBinDir(platform = process.platform) {
+	return platform === "darwin" ? "osx-bin" : "linux64-bin";
+}
+function hermescCandidates(root, { platform = process.platform, reactNativePath = null } = {}) {
+	const bin = hermescBinDir(platform);
+	const rn = reactNativePath ?? join(root, "node_modules", "react-native");
+	return [.../* @__PURE__ */ new Set([
+		join(dirname(rn), "hermes-compiler", "hermesc", bin, "hermesc"),
+		join(root, "node_modules", "hermes-compiler", "hermesc", bin, "hermesc"),
+		join(root, "node_modules", "react-native", "sdks", "hermesc", bin, "hermesc"),
+		join(root, "node_modules", "react-native", "sdks", "hermes", "build", "bin", "hermesc")
+	])];
+}
+function androidHermescPath(root, { exists = existsSync, platform = process.platform, reactNativePath = null } = {}) {
+	const candidates = hermescCandidates(root, {
+		platform,
+		reactNativePath
+	});
+	return candidates.find(exists) ?? candidates[candidates.length - 1];
+}
+function androidHermescArgs({ bundle, out }) {
+	return [
+		"-emit-binary",
+		"-O",
+		"-w",
+		"-out",
+		out,
+		bundle
+	];
+}
+function androidBundleCommand({ isExpo, entryFile, bundleOutput, assetsDest }) {
+	if (isExpo) return {
+		file: "npx",
+		args: [
+			"expo",
+			"export:embed",
+			"--platform",
+			"android",
+			"--dev",
+			"false",
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest
+		]
+	};
+	return {
+		file: "npx",
+		args: [
+			"react-native",
+			"bundle",
+			"--platform",
+			"android",
+			"--dev",
+			"false",
+			"--entry-file",
+			entryFile,
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest
+		]
+	};
+}
+function isNothingToDelete(text) {
+	return /nothing to do|name not matched|no matches found/i.test(String(text ?? ""));
+}
+function zipalignArgs({ buildToolsMajor, input, output }) {
+	return [
+		...buildToolsMajor >= 35 ? ["-P", "16"] : ["-p"],
+		"-f",
+		"-v",
+		"4",
+		input,
+		output
+	];
+}
+function keystorePassArg(value) {
+	const text = typeof value === "string" ? value.trim() : "";
+	if (text === "") return "pass:android";
+	if (/^(?:pass|file|env):/.test(text) || text === "stdin") return text;
+	return `pass:${text}`;
+}
+function resolveKeystore(root, settings) {
+	const android = settings?.["android"];
+	const bag = android && typeof android === "object" && !Array.isArray(android) ? android : {};
+	const configured = bag["keystore"];
+	return {
+		path: typeof configured === "string" && configured.trim() !== "" ? configured.trim().startsWith("/") ? configured.trim() : join(root, configured.trim()) : join(root, "android", "app", "debug.keystore"),
+		pass: keystorePassArg(bag["keystorePassword"])
+	};
+}
+function apksignerArgs({ keystore, apkPath }) {
+	return [
+		"sign",
+		"--ks",
+		keystore.path,
+		"--ks-pass",
+		keystore.pass,
+		apkPath
+	];
+}
+async function swapApkBundle({ root, isExpo, cachedApkPath, keystore, logWriter = null, exec = null, spawnFn = null, mkdtemp = () => makeTemporaryDirectory(cachedApkPath, "stim-apk-swap-"), exists = existsSync, hermesEnabled = null, buildTools = null, findTool = findBuildTool, storedAssets = null, readManifest = readAssetManifest, 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: `APK swap failed at ${step}: ${reason}`,
+			event: "apk_swap"
+		});
+		if (tmp) removeTemporaryEntry(tmp);
+		return {
+			failed: true,
+			step,
+			reason,
+			lastLines,
+			durationMs: elapsed()
+		};
+	};
+	let work;
+	let final;
+	try {
+		tmp = mkdtemp();
+		const base = basename(cachedApkPath);
+		work = join(tmp, `unaligned-${base}`);
+		final = join(tmp, base);
+		try {
+			e.runFile("cp", [
+				"-c",
+				cachedApkPath,
+				work
+			]);
+		} catch {
+			e.runFile("cp", [cachedApkPath, work]);
+		}
+	} catch (err) {
+		return fail("copy", `could not copy ${cachedApkPath} aside: ${describe(err)}`);
+	}
+	const stage = join(tmp, "stage");
+	const bundleOutput = join(stage, "assets", ANDROID_BUNDLE_NAME);
+	const assetsDest = join(stage, "res");
+	const command = androidBundleCommand({
+		isExpo,
+		entryFile: isExpo ? "index.js" : detectEntryFile(root),
+		bundleOutput,
+		assetsDest
+	});
+	try {
+		mkdirSync(join(stage, "assets"), { recursive: true });
+		mkdirSync(assetsDest, { recursive: true });
+	} catch (err) {
+		return fail("bundle", `could not create ${stage}: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `${command.file} ${command.args.join(" ")}`,
+		event: "apk_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: "apk_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 ${ANDROID_BUNDLE_NAME} at ${bundleOutput}`);
+	let hermes = false;
+	let note;
+	if (hermesEnabled ?? readAndroidHermesEnabled(root)) {
+		const hermesc = androidHermescPath(root);
+		if (!exists(hermesc)) note = `hermesc not found at ${hermesc}; embedding the plain JS bundle instead of Hermes bytecode`;
+		else {
+			const hbc = `${bundleOutput}.hbc`;
+			try {
+				e.runFile(hermesc, androidHermescArgs({
+					bundle: bundleOutput,
+					out: hbc
+				}));
+				e.runFile("mv", [hbc, bundleOutput]);
+				hermes = true;
+			} catch (err) {
+				return fail("hermesc", `hermesc failed on ${bundleOutput}: ${describe(err)}`);
+			}
+		}
+	}
+	const refuse = (reason, assetDiff) => {
+		logWriter?.write?.({
+			src: "build",
+			level: "warn",
+			msg: `APK swap refused: ${reason}`,
+			event: "apk_swap"
+		});
+		removeTemporaryEntry(tmp);
+		const result = {
+			assetMismatch: true,
+			reason,
+			durationMs: elapsed()
+		};
+		if (assetDiff) result.assetDiff = assetDiff;
+		return result;
+	};
+	if (!storedAssets) return refuse("this cache entry predates asset tracking (no assets-manifest.json beside the artifact), so its asset set cannot be proven to match this one");
+	const fresh = readManifest(assetsDest);
+	if (!fresh) return fail("assets", `could not hash the assets emitted into ${assetsDest}, so the asset set cannot be verified`);
+	const diff = compareAssetManifests(fresh, storedAssets);
+	if (!diff.same) return refuse(assetDiffReason(diff), diff);
+	try {
+		e.runFile("zip", [
+			"-d",
+			work,
+			ANDROID_BUNDLE_ENTRY
+		]);
+	} catch (err) {
+		if (!isNothingToDelete(describe(err))) return fail("zip", `zip -d ${ANDROID_BUNDLE_ENTRY} failed on ${work}: ${describe(err)}`);
+	}
+	try {
+		e.runFile("zip", [
+			"-0",
+			"-r",
+			work,
+			"assets"
+		], { cwd: stage });
+	} catch (err) {
+		return fail("zip", `zip -0 -r ${work} assets failed: ${describe(err)}`);
+	}
+	const tools = buildTools ?? findTool(["zipalign"]);
+	if (!tools) return fail("zipalign", "no zipalign found under the Android SDK build-tools; install one with `sdkmanager \"build-tools;36.0.0\"`");
+	try {
+		e.runFile(tools.path, zipalignArgs({
+			buildToolsMajor: tools.major,
+			input: work,
+			output: final
+		}));
+	} catch (err) {
+		return fail("zipalign", `zipalign failed on ${work}: ${describe(err)}`);
+	}
+	const signer = buildTools ? {
+		...buildTools,
+		path: join(dirname(buildTools.path), "apksigner")
+	} : findTool(["apksigner"]);
+	if (!signer) return fail("apksigner", "no apksigner found under the Android SDK build-tools; install one with `sdkmanager \"build-tools;36.0.0\"`");
+	try {
+		e.runFile(signer.path, apksignerArgs({
+			keystore,
+			apkPath: final
+		}));
+	} catch (err) {
+		return fail("apksigner", `apksigner sign failed on ${final} with ${keystore.path}: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `APK swap done: ${hermes ? "hermes bytecode" : "plain JS"} into ${final} in ${elapsed()}ms`,
+		event: "apk_swap"
+	});
+	const result = {
+		ok: true,
+		apkPath: final,
+		tmpDir: tmp,
+		hermes,
+		durationMs: elapsed()
+	};
+	if (note) result.note = note;
+	return result;
+}
+function describe(err) {
+	const e = err;
+	const streams = [e?.stdout, e?.stderr].map((s) => s ? String(s).trim() : "").filter(Boolean).join("\n");
+	const message = e?.message ? String(e.message).trim() : String(err);
+	return streams ? `${message}: ${streams}` : message;
+}
+//#endregion
+//#region src/commands/android/support.ts
+const PLATFORM = "android";
+function androidVariantSetting(settings) {
+	const android = settings?.["android"];
+	if (!android || typeof android !== "object" || Array.isArray(android)) return null;
+	const raw = android["variant"];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveVariant(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || androidVariantSetting(settings);
+}
+function androidSystemImageSetting(settings) {
+	const android = settings?.["android"];
+	if (!android || typeof android !== "object" || Array.isArray(android)) return null;
+	const raw = android["systemImage"];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveSystemImage(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || androidSystemImageSetting(settings);
+}
+function systemImageRefusal({ flag, resolved, physical, remoteBackend, listImages }) {
+	if (typeof flag === "string" && flag.trim() === "") return {
+		code: "STIM_BAD_ARG",
+		message: "--system-image was given an empty id.",
+		remedy: "Pass `--system-image <id>` with an sdkmanager package id, e.g. \"system-images;android-36;google_apis;arm64-v8a\"."
+	};
+	if (physical || remoteBackend) return null;
+	if (!resolved) return null;
+	let images;
+	try {
+		images = listImages();
+	} catch (error) {
+		return {
+			code: NO_DEVICE,
+			message: `Could not read the installed Android system images: ${error?.message || error}`,
+			remedy: "Check that ANDROID_HOME points at a readable SDK, then try again."
+		};
+	}
+	const refusal = unknownAndroidSystemImageRefusal(resolved, images);
+	return refusal ? {
+		code: "STIM_BAD_ARG",
+		message: refusal.message,
+		remedy: refusal.remedy
+	} : null;
+}
+function isReleaseVariant(variant) {
+	return typeof variant === "string" && /release$/i.test(variant.trim());
+}
+const NO_METRO = "STIM_NO_METRO";
+const NO_FINGERPRINT = "STIM_NO_FINGERPRINT";
+const NO_DEVICE = "STIM_NO_DEVICE";
+const LAUNCH_FAILED = "STIM_LAUNCH_FAILED";
+function findAapt(home = androidHome(), { readDir = readdirSync, exists = existsSync } = {}) {
+	const found = findBuildTool(["aapt", "aapt2"], {
+		home,
+		readDir,
+		exists
+	});
+	return found ? {
+		path: found.path,
+		tool: found.tool,
+		version: found.version
+	} : null;
+}
+function dumpApkManifest(apkPath, { exec = null, aapt = null } = {}) {
+	if (typeof apkPath !== "string" || apkPath.trim() === "") return null;
+	const tool = aapt || findAapt();
+	if (!tool) return null;
+	const e = exec || getExecutor();
+	const args = tool.tool === "aapt2" ? [
+		"dump",
+		"xmltree",
+		"--file",
+		"AndroidManifest.xml",
+		apkPath
+	] : [
+		"dump",
+		"xmltree",
+		apkPath,
+		"AndroidManifest.xml"
+	];
+	try {
+		const out = e.runFile(tool.path, args);
+		return typeof out === "string" && out.includes("E: manifest") ? out : null;
+	} catch {
+		return null;
+	}
+}
+function parseXmltree(text) {
+	const root = {
+		tag: "#root",
+		attrs: {},
+		children: [],
+		indent: -1
+	};
+	const stack = [root];
+	for (const raw of String(text ?? "").split("\n")) {
+		const indent = raw.search(/\S/);
+		if (indent < 0) continue;
+		const line = raw.trim();
+		const element = /^E: ([\w.:-]+)/.exec(line);
+		if (element) {
+			while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
+			const node = {
+				tag: element[1],
+				attrs: {},
+				children: [],
+				indent
+			};
+			stack[stack.length - 1].children.push(node);
+			stack.push(node);
+			continue;
+		}
+		const attr = /^A: ([^(=]+?)(?:\(0x[0-9a-f]+\))?=(.*)$/.exec(line);
+		if (attr && stack.length > 1) {
+			const name = attr[1].replace(/^http:\/\/schemas\.android\.com\/apk\/res\/android:/, "android:");
+			const value = /^"((?:[^"\\]|\\.)*)"/.exec(attr[2]);
+			stack[stack.length - 1].attrs[name] = value ? value[1] : null;
+		}
+	}
+	return root;
+}
+function eachNode(node, fn) {
+	fn(node);
+	for (const child of node.children) eachNode(child, fn);
+}
+function apkPackage(text) {
+	const pkg = parseXmltree(text).children.find((c) => c.tag === "manifest")?.attrs["package"];
+	return typeof pkg === "string" && pkg.trim() ? pkg.trim() : null;
+}
+function apkDevClientFacts(text) {
+	const root = parseXmltree(text);
+	const facts = {
+		devClient: false,
+		schemes: []
+	};
+	let launchable = null;
+	eachNode(root, (node) => {
+		const name = node.attrs["android:name"];
+		if (typeof name === "string" && name.startsWith("expo.modules.devlauncher")) facts.devClient = true;
+		if (node.tag !== "activity" && node.tag !== "activity-alias") return;
+		const filters = node.children.filter((c) => c.tag === "intent-filter");
+		if (!filters.some((f) => f.children.some((c) => c.tag === "action" && c.attrs["android:name"] === "android.intent.action.MAIN")) || launchable) return;
+		launchable = node;
+		for (const filter of filters) for (const data of filter.children) {
+			if (data.tag !== "data") continue;
+			const scheme = data.attrs["android:scheme"];
+			if (typeof scheme === "string" && scheme.trim()) facts.schemes.push(scheme.trim());
+		}
+	});
+	return facts;
+}
+function androidDevClientScheme(root, apkPath, { exec = null, dump = dumpApkManifest, aapt = null } = {}) {
+	const text = dump(apkPath, {
+		exec,
+		aapt
+	});
+	if (text) {
+		const facts = apkDevClientFacts(text);
+		if (!facts.devClient) return void 0;
+		const scheme = pickDevClientScheme(facts.schemes);
+		if (scheme) return scheme;
+	}
+	return devClientScheme(root, null);
+}
+function noDeviceDiagnostic({ reason, logFile, remedy, localEmulator = true, readLog = readEmulatorLogTail }) {
+	const text = localEmulator ? readLog(logFile) : "";
+	const logPath = text.trim() ? logFile : null;
+	const found = extractEmulatorFailure(text);
+	const diskRemedy = localEmulator ? emulatorDiskSpaceRemedy([reason, ...found]) : null;
+	if (found.length === 0) return {
+		message: reason,
+		remedy: diskRemedy ?? remedy,
+		lines: [],
+		logPath
+	};
+	return {
+		message: `${reason} The emulator reported: ${found[0]}`,
+		remedy: diskRemedy ?? emulatorFailureRemedy(found),
+		lines: found.slice(1),
+		logPath
+	};
+}
+function readEmulatorLogTail(file) {
+	try {
+		return readFileSync(file, "utf-8").split("\n").slice(-400).join("\n");
+	} catch {
+		return "";
+	}
+}
+function displayPath(root, path) {
+	const rel = relative(root, path);
+	return rel && !rel.startsWith("..") ? rel : path;
+}
+async function pooledAndroidDevice({ root, selectPool, listDevices, isEmulatorDevice, deviceModel, waitSeconds, noWait, now, warn }) {
+	const isEmulator = memoizeEmulatorProbe(isEmulatorDevice);
+	const pooled = await selectPool({
+		root,
+		platform: PLATFORM,
+		idLabel: "serial",
+		list: () => androidPoolCandidates(listDevices(), isEmulator).map((entry) => ({ id: entry.serial })),
+		noCandidates: () => {
+			const resolved = androidPoolNoCandidatesRefusal(listDevices(), isEmulator);
+			return {
+				message: resolved.error,
+				remedy: resolved.remedy
+			};
+		},
+		waitSeconds,
+		noWait,
+		now,
+		warn
+	});
+	if (pooled.status === "refused") {
+		const { code, message, remedy, lease } = pooled.refusal;
+		return {
+			code,
+			message,
+			remedy,
+			extra: lease === null ? {} : { lease }
+		};
+	}
+	return { device: {
+		serial: pooled.candidate.id,
+		deviceName: deviceModel(pooled.candidate.id) ?? pooled.candidate.id,
+		owned: false
+	} };
+}
+function androidBuildOptions({ release, physical, device, variant, deviceAbi, compiler, buildProfile, targetAbiOnly = true }) {
+	let abi = null;
+	if (targetAbiOnly && !release && physical && device.serial) abi = deviceAbi(device.serial);
+	if (targetAbiOnly && !release && !physical) abi = androidSystemImageAbi(device.systemImage);
+	const runOptions = {};
+	if (variant) runOptions.variant = variant;
+	if (abi) runOptions.abi = abi;
+	if (compiler) runOptions.compiler = compiler;
+	if (buildProfile) runOptions.buildProfile = buildProfile;
+	return {
+		abi,
+		runOptions,
+		remoteRunOptions: Object.keys(runOptions).length === 0 ? null : runOptions
+	};
+}
+//#endregion
+//#region src/commands/android/result.ts
+function androidFacts({ serial, avdName = null, deviceName = null, systemImage = null, fingerprint, cacheKey = null, variant = null, metroPort = null, cacheHit, cacheSkipped = false, waitedForBuild = null, appPath, bundleId, installSkipped = false, launched, ccache = CCACHE_UNAVAILABLE, logs, debugHttpHost = null, debugHttpHostNote = null, devClientUrl = null, durationMs, lease }) {
+	return {
+		platform: PLATFORM,
+		serial: serial ?? null,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		systemImage: systemImage ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		variant: variant ?? null,
+		metroPort: metroPort ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		waitedForBuild: waitedForBuild ? {
+			pid: waitedForBuild.pid ?? null,
+			ms: waitedForBuild.ms ?? 0
+		} : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		installSkipped: Boolean(installSkipped),
+		launched: launched === "unverified" || launched === "bundling" ? launched : Boolean(launched),
+		ccache,
+		debugHttpHost: debugHttpHost ?? null,
+		debugHttpHostNote: debugHttpHostNote ?? null,
+		devClientUrl: devClientUrl ?? null,
+		logs: logs ?? null,
+		durationMs: typeof durationMs === "number" && Number.isFinite(durationMs) ? durationMs : null,
+		...lease === void 0 ? {} : { lease }
+	};
+}
+function lastBuildRecord({ fingerprint, cacheKey, cacheHit, cacheSkipped = false, durationMs, appPath, bundleId, startedAt, status, errorCode = null, avdName = null, deviceName = null }) {
+	const record = {
+		platform: PLATFORM,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		durationMs: Number.isFinite(durationMs) ? durationMs : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		startedAt,
+		status
+	};
+	if (errorCode) record.errorCode = errorCode;
+	return record;
+}
+async function finishAndroidUpload(uploadPending, remote, phase) {
+	if (!uploadPending) return false;
+	const upload = await uploadPending;
+	if (upload?.uploaded) phase("cache", `uploaded (${remote?.name})`);
+	else if (upload?.timedOut) {
+		phase("cache", chalk.yellow(`${remote?.name} upload still running after ${formatDuration(UPLOAD_TIMEOUT_MS)}; not waiting`));
+		return true;
+	} else if (upload?.failed) {
+		const authNote = remote?.name === "eas" && isEasAuthFailureText(upload.failed) ? easAuthNote({
+			code: "logged-out",
+			reason: upload.failed,
+			phase: "upload"
+		}) : null;
+		phase("cache", chalk.yellow(authNote || `${remote?.name} upload failed: ${upload.failed}`));
+	}
+	return false;
+}
+function reportAndroidResult({ json, useBuildCache, variant, release, metroCheck, metroPort, logsDir, serial, apkPath, androidPackage, installSkipped, record, waitedForBuild, remote, providerName, launchState, launchWarning, launched, ccache, durationMs, writer, emit, lease, recordRun }) {
+	recordRun({
+		failed: false,
+		cacheHit: cacheLevel(record.cacheHit),
+		waited: waitedForBuild,
+		durationMs
+	});
+	const facts = androidFacts({
+		serial,
+		avdName: record.avdName,
+		deviceName: record.deviceName,
+		systemImage: record.systemImage,
+		debugHttpHost: launched.debugHttpHost ?? null,
+		debugHttpHostNote: launched.debugHttpHostNote ?? null,
+		devClientUrl: launched.devClientUrl ?? null,
+		fingerprint: record.fingerprint,
+		cacheKey: record.cacheKey,
+		variant,
+		metroPort,
+		cacheHit: record.cacheHit,
+		cacheSkipped: !useBuildCache,
+		waitedForBuild,
+		appPath: apkPath,
+		bundleId: androidPackage,
+		installSkipped,
+		launched: launchState,
+		ccache,
+		logs: logsDir,
+		durationMs,
+		lease
+	});
+	writer.close();
+	if (json) emit(JSON.stringify(facts));
+	else {
+		const summary = `${launchWarning ? "WARNING" : "OK"}: ${androidPackage} launched on ${serial}, ${release ? `${variant} (embedded JS, no Metro)` : `Metro port ${metroPort}`} (${cacheOutcome(record.cacheHit, remote?.name ?? providerName)})`;
+		const outcome = launchWarning ? chalk.yellow(`${summary} -- ${launchWarning}`) : launchState === "unverified" ? chalk.yellow(`${summary} -- launch UNVERIFIED`) : launchState === "bundling" ? chalk.green(`${summary} -- bundle requested, still building`) : chalk.green(summary);
+		const deviceName = record.avdName || record.deviceName || serial;
+		const cacheResult = useBuildCache ? cacheOutcome(record.cacheHit, remote?.name ?? providerName) : "bypassed; built";
+		const metroResult = release ? `embedded (${variant})` : !metroCheck ? `check skipped on port ${metroPort}` : launchState === "unverified" ? `state unverified on port ${metroPort}` : `running on port ${metroPort}`;
+		emit([
+			outcome,
+			phaseLine("device", `${deviceName} (${serial})`),
+			phaseLine("app", androidPackage),
+			phaseLine("metro", metroResult),
+			phaseLine("cache", cacheResult),
+			...ccache.status === "not-run" ? [phaseLine("compilation cache", ccacheActivityLine(ccache))] : [],
+			phaseLine("logs", logsDir || "unavailable (remote device)")
+		].join("\n"));
+	}
+	return facts;
+}
+function cacheOutcome(cacheHit, providerName = null) {
+	if (cacheHit === "remote") return `cache hit from ${providerName || "the remote cache"}`;
+	if (cacheHit === "local") return "cache hit";
+	return "built";
+}
+function persistLastBuild({ writeState, root, record, startedAt, durationMs, status, errorCode = null, out }) {
+	const lastBuild = lastBuildRecord({
+		...record,
+		startedAt,
+		durationMs,
+		status,
+		errorCode
+	});
+	try {
+		writeState(root, { lastBuild });
+	} catch (err) {
+		out(phaseLine("state", chalk.yellow(`could not record lastBuild: ${err?.message || err}`)));
+	}
+	return lastBuild;
+}
+//#endregion
+//#region src/commands/android/collector.ts
+function collectorEntry() {
+	return spawnEntry("collector-run");
+}
+function collectorLogFile(root) {
+	return join(workspaceLogsDir(root), `collector-${PLATFORM}.log`);
+}
+const COLLECTOR_EXIT_WAIT_MS = 2e3;
+const COLLECTOR_POLL_MS = 25;
+function killPreviousCollector(root, { platform = PLATFORM, kill = (pid, signal) => process.kill(pid, signal), collectors = null, verify = verifyCollectorOwnership, isAlive = pidExists, note = (_line) => {} } = {}) {
+	const record = (collectors ?? readCollectors(root))?.[platform];
+	const pid = Number(record?.pid);
+	if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return null;
+	const ownership = verify({
+		pid,
+		platform,
+		root,
+		isAlive,
+		expected: record
+	});
+	if (ownership.status === "gone") return null;
+	if (ownership.status === "unverified") {
+		note(chalk.dim(`Previous ${platform} log collector (pid ${pid}): ${ownership.reason}, so it was not signalled -- starting a replacement anyway`));
+		return null;
+	}
+	try {
+		kill(pid, "SIGTERM");
+		return pid;
+	} catch {
+		return null;
+	}
+}
+async function startCollector({ root, serial, packageName, spawn, kill, alive = pidExists, verify = verifyCollectorOwnership, waitMs = COLLECTOR_EXIT_WAIT_MS, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), out }) {
+	const previousPid = killPreviousCollector(root, {
+		kill,
+		isAlive: alive,
+		verify,
+		note: (line) => out(phaseLine("logs", line))
+	});
+	if (previousPid) {
+		const deadline = Date.now() + waitMs;
+		while (Date.now() < deadline && alive(previousPid)) await sleep(COLLECTOR_POLL_MS);
+	}
+	let stdio = "ignore";
+	try {
+		mkdirSync(workspaceLogsDir(root), { recursive: true });
+		const fd = openSync(collectorLogFile(root), "a");
+		stdio = [
+			"ignore",
+			fd,
+			fd
+		];
+	} catch {}
+	try {
+		const child = spawn(process.execPath, [
+			collectorEntry(),
+			"--platform",
+			PLATFORM,
+			"--root",
+			root,
+			"--serial",
+			serial,
+			"--package",
+			packageName
+		], {
+			cwd: root,
+			detached: true,
+			stdio,
+			env: process.env
+		});
+		child?.unref?.();
+		return child?.pid ?? null;
+	} catch (err) {
+		out(phaseLine("logs", chalk.yellow(`could not start the device log collector: ${err?.message || err}`)));
+		return null;
+	}
+}
+//#endregion
+//#region src/commands/android/launch.ts
+async function verifyAndroidRun({ root, release, remoteRelease, remoteDevice, verifyReleaseLaunched, verifyLaunched, serial, androidPackage, variant, metroCheck, logsDir, launchedAt, metroPort, isExpo, physical, scheme, component = null, phase }) {
+	const readNativeCrashes = () => remoteDevice ? [] : captureNativeCrashes({
+		root,
+		platform: "android",
+		deviceId: serial,
+		appId: androidPackage,
+		since: launchedAt
+	}, logsDir);
+	if (remoteRelease) {
+		phase("verify", chalk.yellow("UNVERIFIED: remote adapter launch accepted; process verification is unavailable"));
+		return { state: LAUNCH_UNVERIFIED };
+	}
+	if (release) {
+		const processCheck = await verifyReleaseLaunched({
+			serial,
+			packageName: androidPackage
+		});
+		const crashes = readNativeCrashes();
+		if (processCheck?.verified && !crashes.length) {
+			phase("verify", `process alive ${formatDuration(processCheck.waitedMs ?? 0)} after launch (${variant}: no bundle fetch to observe)`);
+			return { state: true };
+		}
+		if (processCheck?.reason === "probe-failed" && !crashes.length) {
+			phase("verify", chalk.yellow("UNVERIFIED: the app process check failed"));
+			return { state: LAUNCH_UNVERIFIED };
+		}
+		for (const line of launchErrorPreview(crashes, root)) phase("launch", chalk.red(line));
+		if (!crashes.length) phase("logs", "Process missing; no attributable native crash report captured. Read `stim logs --source device` for available output.");
+		phase("verify", chalk.yellow(crashes.length ? "FATAL: the app reported a native crash" : `FATAL: no ${androidPackage} process on ${serial} ${formatDuration(processCheck?.waitedMs ?? 0)} after launch`));
+		phase("", chalk.yellow("A release process exited before readiness. Run `stim logs --errors` for captured crash reports, or `stim logs --source device` for the full device output."));
+		return { state: LAUNCH_FATAL };
+	}
+	const verification = metroCheck ? await verifyLaunched({
+		onReadinessPending: () => phase("readiness", "waiting for app readiness (up to 30s after bundle load)"),
+		logsDir,
+		since: launchedAt,
+		metroPort,
+		platform: "android",
+		mode: isExpo ? MODE_EXPO : MODE_BARE,
+		readNativeCrashes,
+		processAlive: () => {
+			const pid = androidAppProcess(serial, androidPackage);
+			return pid === void 0 ? null : pid !== null;
+		}
+	}) : {
+		verified: false,
+		skipped: true
+	};
+	const nativeCrashes = verification.errors?.some((record) => record.event === "native_crash") ? [] : readNativeCrashes();
+	if (nativeCrashes.length) verification.fatal = true;
+	verification.errors = await errorDiagnostics([...verification.errors ?? [], ...nativeCrashes], {
+		root,
+		logsDir,
+		port: metroPort,
+		allowRequest: true
+	});
+	if (verification.readiness) phase("readiness", appReadinessMessage(verification.readiness, verification.waitedMs ?? 0));
+	if (verification?.fatal) {
+		const nativeFatal = verification.errors?.some((record) => record.event === "native_crash");
+		const deliveryFailed = verification.record?.event === "bundle_response_failed";
+		const reason = nativeFatal ? "the app reported a native crash" : verification.processAlive === false ? "the app process exited" : deliveryFailed ? "Metro bundle delivery failed" : "Metro could not build the bundle";
+		phase("verify", chalk.red(`FATAL after ${formatDuration(verification.waitedMs ?? 0)}: ${reason}`));
+		for (const line of launchErrorPreview(verification.errors ?? [], root)) phase("", chalk.red(line));
+		if (verification.processAlive === false && !verification.errors?.some((record) => record.event === "native_crash")) phase("logs", "No attributable native crash report captured yet. Run `stim logs --errors` again for delayed reports, or `stim logs --source device` for available output.");
+		if (nativeFatal || verification.processAlive === false) phase("remedy", chalk.yellow(`Fix the crash, then restart the app: \`adb -s ${deviceShellArg(serial)} shell am force-stop ${deviceShellArg(androidPackage)}\`, then run \`stim android\` again. A crashed Android process can remain alive behind the system crash dialog; Metro reload cannot recover it.`));
+		else if (verification.processAlive === true && metroPort !== null) {
+			const reloadRemedy = physical ? `run \`agent-device metro reload --metro-port ${metroPort}\`.` : "run `stim reload android`.";
+			phase("remedy", chalk.yellow(`The native app is still running. ${deliveryFailed ? "Check the Metro logs and device connection, then" : "Fix the JavaScript or TypeScript error, then"} ${reloadRemedy} Do not run \`stim android\` unless native inputs changed or the app process exits.`));
+		}
+		return { state: LAUNCH_FATAL };
+	}
+	if (verification?.verified) {
+		phase("verify", `bundle loaded` + (verification.processAlive === true ? ", process alive" : "") + (verification.readiness ? "" : ", stable for 3s -- the first screen may still be rendering") + ` (${formatDuration(verification.waitedMs ?? 0)} total)`);
+		const report = launchErrorReport(verification.errors ?? [], root);
+		if (report.summary) phase("launch", chalk.dim(report.summary));
+		for (const line of report.lines) phase("launch", chalk.yellow(line));
+		if (report.lines.length > 0 && verification.processAlive === true && metroPort !== null) {
+			const reloadRemedy = physical ? `run \`agent-device metro reload --metro-port ${metroPort}\`.` : "run `stim reload android`.";
+			phase("remedy", chalk.yellow(`The native app is still running. Fix the JavaScript or TypeScript error; Fast Refresh should apply the edit. If the error screen remains, ${reloadRemedy} Do not run \`stim android\` unless native inputs changed or the app process exits.`));
+		}
+		return {
+			state: true,
+			warning: report.lines.length > 0 ? "app errors detected; inspect the error above" : verification.readiness === "timed-out" || verification.readiness === "error" ? "app readiness not confirmed; inspect the UI and logs" : void 0
+		};
+	}
+	if (verification?.skipped) {
+		phase("verify", "skipped (--no-metro-check): the launch is reported as unverified");
+		return { state: LAUNCH_UNVERIFIED };
+	}
+	if (verification?.requested) {
+		phase("verify", `BUNDLING: the app asked port ${metroPort} for its bundle; build, delivery, or JavaScript loading was still pending after ${formatDuration(verification.waitedMs ?? 0)} (a cold bundle on a large graph outlasts this window)`);
+		phase("", chalk.dim("Nothing to do: `stim logs --source metro` shows the build finishing, usually within a minute."));
+		return { state: LAUNCH_BUNDLING };
+	}
+	phase("verify", chalk.yellow("UNVERIFIED: no bundle request reached this workspace's Metro"));
+	for (const line of unverifiedLaunchLines({
+		platform: PLATFORM,
+		metroPort: metroPort ?? 8081,
+		waitedMs: verification?.waitedMs,
+		bundleId: androidPackage,
+		serial,
+		component,
+		devClientUrl: scheme ? androidDevClientUrl(scheme, metroPort ?? 8081, physical) : null,
+		mode: isExpo ? MODE_EXPO : MODE_BARE
+	})) phase("", chalk.yellow(line));
+	return { state: LAUNCH_UNVERIFIED };
+}
+async function finishAndroidRun({ lease, releaseLease, root, json, metroCheck, useBuildCache, variant, release, isExpo, metroPort, logsDir, emuLog, device, physical, remoteDevice, bootPromise, bootDuration, apkPath, androidPackage: initialPackage, swapDir, record, waitedForBuild, ccache, uploadPending, providerUpload, providerName, remote, abandonedRemote: remoteWasAbandoned, started, startedAt, writer, phase, fail, readApkPackage, install, launch, launchRelease, resolveDevClientScheme, verifyLaunched, verifyReleaseLaunched, spawn, kill, pidAlive, verifyCollector, writeLaunch, writeState, now, out, emit, recordRun }) {
+	let androidPackage = initialPackage;
+	let leaseWarned = false;
+	const raiseLeaseFor = (boundMs, beforeInstall) => {
+		const step = lease?.raise(boundMs);
+		if (!step || step.ok) return null;
+		if (beforeInstall) {
+			const refusal = lostRefusal(step.holder, step.expiresAt, now());
+			return fail(refusal.code, refusal.message, refusal.remedy, { lease: refusal.lease });
+		}
+		if (!leaseWarned) {
+			leaseWarned = true;
+			phase("lease", chalk.yellow(lostLine(step.holder, step.expiresAt, now())));
+		}
+		return null;
+	};
+	const booted = await bootPromise;
+	if (booted.failed) {
+		const diag = noDeviceDiagnostic({
+			reason: booted.reason ?? "The emulator did not boot.",
+			logFile: emuLog,
+			remedy: "Run `stim status` to see what Stim thinks it owns; re-running `stim android` creates a fresh owned AVD.",
+			localEmulator: !physical
+		});
+		return fail(NO_DEVICE, diag.message, diag.remedy, {
+			lines: diag.lines,
+			logPath: diag.logPath ? displayPath(root, diag.logPath) : null
+		});
+	}
+	const serial = booted.serial;
+	phase("device", physical ? `${device.deviceName || serial} (${serial}) connected, not owned by Stim` : `${device.avdName || serial} (${serial}) ${device.adopted || device.adoptionPending ? "adopted" : "booted"} ${bootDuration()}`);
+	const packageFromApk = readApkPackage(apkPath);
+	if (packageFromApk && androidPackage && packageFromApk !== androidPackage) phase("install", chalk.dim(`applicationId ${packageFromApk} (from the APK; project files say ${androidPackage})`));
+	androidPackage = packageFromApk || androidPackage || detectAndroidPackage(root);
+	const adopting = !physical && !remoteDevice && Boolean(device.adoptionPending);
+	if (adopting) {
+		if (!androidPackage || !device.avdName) return fail(LAUNCH_FAILED, "Cannot clean an adopted emulator without its app package and AVD name.", "Retry once the APK applicationId can be read.");
+		try {
+			await resetAdoptedAvd(device.avdName, serial, androidPackage);
+		} catch (error) {
+			return fail(LAUNCH_FAILED, `Could not clean adopted emulator ${device.avdName}: ${String(error?.message || error)}`, "Fix the device cleanup error and retry; adoption remains pending and the app was not launched.");
+		}
+	}
+	const lostBeforeInstall = physical ? raiseLeaseFor(ADB_INSTALL_TIMEOUT_MS, true) : null;
+	if (lostBeforeInstall) return lostBeforeInstall;
+	const installTimer = stepTimer(now);
+	const installed = install({
+		serial,
+		apkPath,
+		packageName: androidPackage,
+		allowUninstall: release || adopting
+	});
+	if (installed.failed) {
+		const conflict = installConflictKind(installed.reason);
+		const rerun = useBuildCache ? " Then run this command again; it installs the APK from cache without building it again." : " Then run this command again.";
+		const installRemedy = conflict ? `${androidPackage} is already installed on ${serial} ` + (conflict === "signature" ? "with a different signer" : "at a higher versionCode") + `. Uninstall it first (\`adb -s ${serial} uninstall ${androidPackage}\`); its data goes with it.` + rerun : `Check that ${serial} is still connected (\`adb devices\`) and has room for the APK.`;
+		return fail(installed.code || "STIM_INSTALL_FAILED", installed.reason, installRemedy, { lastBuildStatus: true });
+	}
+	if (adopting) try {
+		withConfigLock(() => {
+			const config = loadConfig();
+			const current = config?.projects?.[root]?.platforms?.android;
+			if (!config || !current || current.avdName !== device.avdName) throw new Error("The adopted emulator assignment changed during installation.");
+			delete current.adoptionPending;
+			saveConfig(config);
+		});
+	} catch (error) {
+		return fail(LAUNCH_FAILED, `Could not finish adopting emulator ${device.avdName}: ${String(error?.message || error)}`, "Retry to reconcile the emulator assignment; the app was not launched.");
+	}
+	const installSkipped = Boolean(installed.skipped);
+	phase("install", installSkipped ? `unchanged (${serial} already has this build) ${installTimer()}` : `${basename(apkPath)} -> ${serial} ${installTimer()}`);
+	if (installed.note) {
+		phase("install", chalk.yellow(installed.note));
+		writer.write({
+			src: "build",
+			level: "warn",
+			event: "install_uninstalled_first",
+			msg: installed.note
+		});
+	}
+	if (swapDir) try {
+		rmSync(swapDir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	if (androidPackage) upsertProject(root, { androidPackage });
+	record.bundleId = androidPackage;
+	if (!androidPackage) return fail(LAUNCH_FAILED, "Could not determine this app's Android package name, so there is nothing to launch.", "Set `expo.android.package` in app.json / app.config.js, or `namespace` in android/app/build.gradle.", { lastBuildStatus: true });
+	if (physical) raiseLeaseFor(0, false);
+	const scheme = release ? void 0 : resolveDevClientScheme(root, apkPath);
+	const launchTimer = stepTimer(now);
+	const launchedAt = now();
+	writer.write({
+		src: "build",
+		level: "info",
+		marker: true,
+		event: "launch_attempt",
+		ts: launchedAt,
+		platform: "android",
+		appId: androidPackage,
+		deviceId: serial,
+		remote: Boolean(remoteDevice),
+		physical,
+		msg: `launching ${androidPackage} on ${serial}`
+	});
+	const launched = release ? remoteDevice ? remoteDevice.launch({
+		serial,
+		packageName: androidPackage,
+		metroPort: null
+	}) : launchRelease({
+		serial,
+		packageName: androidPackage
+	}) : launch({
+		serial,
+		packageName: androidPackage,
+		metroPort: metroPort ?? 8081,
+		devClientScheme: scheme,
+		physical
+	});
+	if (launched.failed) {
+		printNativeCrashReport({
+			root,
+			platform: "android",
+			deviceId: serial,
+			appId: androidPackage,
+			since: launchedAt
+		}, logsDir, (line) => phase("launch", chalk.red(line)), Boolean(remoteDevice));
+		return fail(launched.code || "STIM_LAUNCH_FAILED", launched.reason, `Check the app installed correctly (\`adb -s ${serial} shell pm list packages ${androidPackage}\`).`, { lastBuildStatus: true });
+	}
+	writer.write({
+		src: "build",
+		level: "info",
+		event: "app_launched",
+		msg: release ? `launched ${androidPackage} on ${serial} (${variant}, embedded JS bundle, no Metro)` : `launched ${androidPackage} on ${serial} against Metro port ${metroPort}`
+	});
+	phase("launch", `${androidPackage} ${launchTimer()}`);
+	if (!physical && !remoteDevice) try {
+		writeLaunch(root, "android", {
+			appId: androidPackage,
+			deviceId: serial,
+			metroPort,
+			release,
+			launchedAt: new Date(launchedAt).toISOString()
+		});
+	} catch (error) {
+		out(phaseLine("state", chalk.yellow(`could not record Android launch: ${error?.message || error}`)));
+	}
+	const reversedSummary = (launched.reversed ?? []).join(", ") || `tcp:${metroPort}->tcp:${metroPort}`;
+	if (!release && launched.debugHttpHost) phase("metro", `debug_http_host ${launched.debugHttpHost} + adb reverse ${reversedSummary}`);
+	else if (!release) {
+		phase("metro", chalk.yellow(`adb reverse ${reversedSummary}; ${launched.debugHttpHostNote || "debug_http_host not written"}`));
+		writer.write({
+			src: "build",
+			level: "warn",
+			event: "debug_http_host_failed",
+			msg: `debug_http_host was not written for ${androidPackage} on ${serial}: ${launched.debugHttpHostNote || "unknown reason"}`
+		});
+	}
+	if (launched.devClientNote) {
+		phase("metro", chalk.yellow(launched.devClientNote));
+		writer.write({
+			src: "build",
+			level: "warn",
+			event: "dev_client_link_failed",
+			msg: launched.devClientNote
+		});
+	}
+	const uploadWasAbandoned = await finishAndroidUpload(uploadPending, remote, phase);
+	const providerOutcome = providerUploadOutcome(providerUpload ? await providerUpload : null, providerName);
+	if (providerOutcome) phase("cache", providerOutcome.warn ? chalk.yellow(providerOutcome.line) : providerOutcome.line);
+	persistLastBuild({
+		writeState,
+		root,
+		record,
+		startedAt,
+		durationMs: now() - started,
+		status: "ok",
+		out
+	});
+	const remoteRelease = Boolean(remoteDevice && release);
+	if (!remoteRelease) {
+		if (physical) raiseLeaseFor(0, false);
+		const collectorPid = await startCollector({
+			root,
+			serial,
+			packageName: androidPackage,
+			spawn,
+			kill,
+			alive: pidAlive,
+			verify: verifyCollector,
+			out
+		});
+		phase("logs", `${displayPath(root, logsDir)}${collectorPid ? ` (collector pid ${collectorPid})` : ""}`);
+	}
+	if (physical) raiseLeaseFor(release ? RELEASE_VERIFY_WAIT_MS : DEBUG_VERIFY_STEP_MS, false);
+	const { state: launchState, warning: launchWarning } = await verifyAndroidRun({
+		root,
+		release,
+		remoteRelease,
+		remoteDevice: Boolean(remoteDevice),
+		verifyReleaseLaunched,
+		verifyLaunched,
+		serial,
+		androidPackage,
+		variant,
+		metroCheck,
+		logsDir,
+		launchedAt,
+		metroPort,
+		isExpo,
+		physical,
+		scheme,
+		component: launched.component ?? null,
+		phase
+	});
+	if (launchState === "fatal") return fail(LAUNCH_FAILED, "The app failed its launch readiness check.", `Read the launch error above or run \`stim logs --errors\`. The full timeline is in ${logsDir}.`, {
+		lastBuildStatus: true,
+		logPath: displayPath(root, logsDir)
+	});
+	writer.write(launchOutcomeRecord({
+		launchState,
+		release,
+		bundleId: androidPackage,
+		configuration: variant,
+		metroPort
+	}));
+	const leaseFacts = lease?.facts() ?? null;
+	releaseLease();
+	const facts = reportAndroidResult({
+		json,
+		useBuildCache,
+		variant,
+		release,
+		metroCheck,
+		metroPort,
+		logsDir: remoteRelease ? null : logsDir,
+		serial,
+		apkPath,
+		androidPackage,
+		installSkipped,
+		record,
+		waitedForBuild,
+		remote,
+		providerName,
+		launchState,
+		launchWarning,
+		launched,
+		ccache,
+		durationMs: now() - started,
+		writer,
+		emit,
+		lease: physical ? leaseFacts : void 0,
+		recordRun
+	});
+	if (remoteWasAbandoned || uploadWasAbandoned) exitAfterFlush(0);
+	return {
+		ok: true,
+		facts
+	};
+}
+//#endregion
+//#region src/commands/android.ts
+const FALLBACK_LINES = 5;
+function androidCompilerCache({ root, optimizations, settingsContext }) {
+	const { cas, optimizations: resolved } = resolveAndroidCompilerCache({
+		optimizations,
+		use: (manifest) => resolveAndroidCas(root, {
+			...process.env,
+			STIM_ANDROID_CAS_TOOLCHAIN: manifest
+		})
+	});
+	const fallback = resolved.android.compilerCacheFallback;
+	if (!fallback) return {
+		cas,
+		optimizations: resolved,
+		warning: null
+	};
+	return {
+		cas,
+		optimizations: resolved,
+		warning: `Warning: ${compilerCacheFallbackMessage({
+			fallback,
+			compilerCache: resolved.android.compilerCache === "none" ? "none" : "ccache",
+			file: settingFile(settingsContext, fallback.key)
+		})}`
+	};
+}
+function androidCommand(program) {
+	registerAndroid(program);
+}
+function registerAndroid(program) {
+	program.command("android").description("Build (or install from the shared cache), install and launch this workspace's Android app on its owned emulator, wired to the reserved Metro port. Never starts the bundler -- run `stim start` first.").option("--json", "Emit the facts as a single JSON line on stdout; every other line goes to stderr").option("--no-metro-check", "Skip the reserved-port Metro health check (the app will load no bundle unless something else serves it)").option("--no-build-cache", "Build fresh, ignoring cached artifacts (local and the project's build-cache provider); the fresh build still replaces the cache entry").option("--variant <name>", "Gradle variant to assemble and install (e.g. productionDebug on a flavored project); overrides the android.variant setting. A variant ending in Release embeds the JS bundle and skips Metro entirely. Default: debug").option("--system-image <id>", "Android system image to create this workspace's owned AVD from, as the sdkmanager package id (e.g. \"system-images;android-36;google_apis;arm64-v8a\"). Overrides the android.systemImage setting for this invocation. An unknown id refuses with STIM_BAD_ARG and prints the installed images.").option("--device [serial]", "Install and launch on a connected physical device instead of this workspace's owned emulator. With no serial, the first connected device this workspace can lease is used. Stim never creates, boots, or deletes a physical device.").option("--remote <backend>", "Install and launch on a remote device with proxy or EAS. The build still happens here.", (value) => {
+		if (REMOTE_DEVICE_BACKENDS.includes(value)) return value;
+		throw new InvalidArgumentError(`expected one of: ${REMOTE_DEVICE_BACKENDS.join(", ")}`);
+	}).option("--wait <seconds>", "How long to wait for another workspace to release the device it leases, before refusing with STIM_DEVICE_BUSY (default 60, 0 refuses at once). Only with --device.").option("--no-wait", "Install on a device another workspace leases instead of waiting: this run takes no lease and, when both workspaces build the same app id, the install terminates the holder's running app. Only with --device.").action(async (opts) => {
+		const root = findProjectRoot(process.cwd());
+		if (!root) {
+			console.error(chalk.red("Not in a React Native project (no package.json found)."));
+			process.exit(1);
+			return;
+		}
+		if (!(await runAndroid({
+			root,
+			json: Boolean(opts.json),
+			metroCheck: opts.metroCheck !== false,
+			useBuildCache: opts.buildCache !== false,
+			variant: opts.variant ?? null,
+			systemImage: opts.systemImage ?? null,
+			remoteDevice: opts.remote ?? null,
+			device: opts.device ?? null,
+			wait: opts.wait,
+			waitConflict: waitFlagConflict(process.argv)
+		})).ok) process.exit(1);
+	});
+}
+function resolveRunAndroidOptions({ root, json = false, remoteDevice: commandRemoteBackend = null, resolveSettingsFor = resolveSettings, resolveRemoteDeviceContext = resolveRemoteContext, remoteDeviceDeps: makeRemoteDeviceDeps = remoteAndroidDeps, resolveEasBin = resolveEasCliBin, ensureMetroReachable: ensureRemoteMetro = ensureMetroReachable, ensureRemoteBootOwned: ensureRemoteOwned = ensureRemoteBootOwned, detectRemoteProviders = detectProviders, metroCheck = true, useBuildCache = true, variant: variantFlag = null, systemImage: systemImageFlag = null, device: deviceFlag = null, wait: waitFlag = void 0, waitConflict = false, acquireLease = acquireRunLease, makeRunLease = runLease, selectPool = selectFromPool, onLeaseSignal = releaseLeaseOnSignal, listDevices = listAdbDevices, deviceModel = physicalDeviceModel, deviceAbi = androidDeviceAbi, isEmulatorDevice = probeEmulatorSerial, readApkPackage = (apkPath) => apkPackage(dumpApkManifest(apkPath)), getLimits = getConcurrencyLimits, checkCapacity = checkDeviceCapacity, acquireSlot = acquireBuildSlot, releaseSlot = releaseBuildSlot, ensureDevice = ensureOwnedDevice, listSystemImages = listInstalledSystemImages, ensureDeviceBooted = ensureBooted, resolveMetro = resolveProjectMetro, resolveMetroRetrying = resolveMetroWithRetry, readState = readWorkspaceState, pidAlive = pidExists, verifyCollector = verifyCollectorOwnership, verifyLaunched = verifyLaunch, ensureStorage = ensureWorkspaceStorageSafely, fingerprint = fingerprintProject, untracked = untrackedNativeFiles, resolveCached = resolveBuild, storeCached = storeBuild, storedAssets = storedAssetManifest, captureAssets = captureAssetManifest, acquireLock = acquireBuildLock, releaseLock = releaseBuildLock, waitForBuild: waitForBuild$1 = waitForBuild, loadProvider = loadProjectProvider, easAuth = checkEasAuth, resolveRemoteBuild = resolveRemote, uploadRemoteBuild = uploadRemote, resolveCacheProvider = resolveCacheProviderConfig, loadCacheProviderModule = loadCacheProvider, needsPrebuildFor = needsPrebuild, prebuild = runPrebuild, build = buildAndroid, ccacheFor = resolveCcache, install = installAndroidApp, launch = launchAndroidApp, launchRelease = launchAndroidReleaseApp, verifyReleaseLaunched = verifyAndroidReleaseLaunch, swapApk = swapApkBundle, resolveDevClientScheme = androidDevClientScheme, spawn = (cmd, args, opts) => getExecutor().spawn(cmd, args, opts), kill = (pid, signal) => process.kill(pid, signal), createWriter = createNdjsonWriter, writeLaunch = writeWorkspaceLaunch, writeState = writeWorkspaceState, recordStats = recordRunStats, readEstimates = readRunEstimates, now = Date.now, out = (line) => console.error(line), emit = (line) => console.log(line) } = {}) {
+	return {
+		root,
+		json,
+		commandRemoteBackend,
+		resolveSettingsFor,
+		resolveRemoteDeviceContext,
+		makeRemoteDeviceDeps,
+		resolveEasBin,
+		ensureRemoteMetro,
+		ensureRemoteOwned,
+		detectRemoteProviders,
+		metroCheck,
+		useBuildCache,
+		variantFlag,
+		systemImageFlag,
+		deviceFlag,
+		waitFlag,
+		waitConflict,
+		acquireLease,
+		makeRunLease,
+		selectPool,
+		onLeaseSignal,
+		listDevices,
+		deviceModel,
+		deviceAbi,
+		isEmulatorDevice,
+		readApkPackage,
+		getLimits,
+		checkCapacity,
+		acquireSlot,
+		releaseSlot,
+		ensureDevice,
+		listSystemImages,
+		ensureDeviceBooted,
+		resolveMetro,
+		resolveMetroRetrying,
+		readState,
+		pidAlive,
+		verifyCollector,
+		verifyLaunched,
+		ensureStorage,
+		fingerprint,
+		untracked,
+		resolveCached,
+		storeCached,
+		storedAssets,
+		captureAssets,
+		acquireLock,
+		releaseLock,
+		waitForBuild: waitForBuild$1,
+		loadProvider,
+		easAuth,
+		resolveRemoteBuild,
+		uploadRemoteBuild,
+		resolveCacheProvider,
+		loadCacheProviderModule,
+		needsPrebuildFor,
+		prebuild,
+		build,
+		ccacheFor,
+		install,
+		launch,
+		launchRelease,
+		verifyReleaseLaunched,
+		swapApk,
+		resolveDevClientScheme,
+		spawn,
+		kill,
+		createWriter,
+		writeLaunch,
+		writeState,
+		recordStats,
+		readEstimates,
+		now,
+		out,
+		emit
+	};
+}
+async function runAndroid(options = {}) {
+	let { root, json, commandRemoteBackend, resolveSettingsFor, resolveRemoteDeviceContext, makeRemoteDeviceDeps, resolveEasBin, ensureRemoteMetro, ensureRemoteOwned, detectRemoteProviders, metroCheck, useBuildCache: requestedBuildCache, variantFlag, systemImageFlag, deviceFlag, waitFlag, waitConflict, acquireLease, makeRunLease, selectPool, onLeaseSignal, listDevices, deviceModel, deviceAbi, isEmulatorDevice, readApkPackage, getLimits, checkCapacity, acquireSlot, releaseSlot, ensureDevice, listSystemImages, ensureDeviceBooted, resolveMetro, resolveMetroRetrying, readState, pidAlive, verifyCollector, verifyLaunched, ensureStorage, fingerprint, untracked, resolveCached, storeCached, storedAssets, captureAssets, acquireLock, releaseLock, waitForBuild, loadProvider, easAuth, resolveRemoteBuild, uploadRemoteBuild, resolveCacheProvider, loadCacheProviderModule, needsPrebuildFor, prebuild, build, ccacheFor, install, launch, launchRelease, verifyReleaseLaunched, swapApk, resolveDevClientScheme, spawn, kill, createWriter, writeLaunch, writeState, recordStats, readEstimates, now, out, emit } = resolveRunAndroidOptions(options);
+	const started = now();
+	const startedAt = new Date(started).toISOString();
+	const projectProblem = appProjectProblem(root);
+	if (projectProblem) {
+		const { message, remedy } = projectProblem;
+		out(phaseLine("error", chalk.red(`STIM_NO_PROJECT: ${message}`)));
+		out(phaseLine("remedy", remedy));
+		if (json) emit(JSON.stringify({
+			code: "STIM_NO_PROJECT",
+			message,
+			remedy
+		}));
+		return {
+			ok: false,
+			error: {
+				code: "STIM_NO_PROJECT",
+				message,
+				remedy
+			}
+		};
+	}
+	try {
+		await ensureStorage(root, { note: out });
+	} catch (error) {
+		const code = error?.code || "STIM_WORKSPACE_STATE";
+		const message = `Could not prepare this workspace's Stim state: ${error?.message || error}`;
+		const remedy = "Check that STIM_HOME is writable and has free space. An EPERM on a directory you can write is a sandbox: allow writes to STIM_HOME, or run Stim with the sandbox disabled (`stim guide errors sandbox`).";
+		out(phaseLine("error", chalk.red(`${code}: ${message}`)));
+		out(phaseLine("remedy", remedy));
+		if (json) emit(JSON.stringify({
+			code,
+			message,
+			remedy
+		}));
+		return {
+			ok: false,
+			error: {
+				code,
+				message,
+				remedy
+			}
+		};
+	}
+	const logsDir = workspaceLogsDir(root);
+	const buildLog = join(logsDir, "build-android.ndjson");
+	const writer = createWriter(buildLog, { truncate: true });
+	const record = {
+		fingerprint: null,
+		cacheKey: null,
+		cacheHit: false,
+		appPath: null,
+		bundleId: null,
+		avdName: null,
+		deviceName: null
+	};
+	let buildLock = null;
+	const releaseHeldLock = () => {
+		if (!buildLock) return;
+		const held = buildLock;
+		buildLock = null;
+		try {
+			releaseLock(held);
+		} catch (err) {
+			out(phaseLine("build", chalk.dim(`could not release the build lock at ${held.path}: ${err?.message || err}`)));
+		}
+	};
+	let buildSlot = null;
+	const releaseHeldSlot = () => {
+		if (!buildSlot) return;
+		const held = buildSlot;
+		buildSlot = null;
+		try {
+			releaseSlot(held);
+		} catch (err) {
+			out(phaseLine("build", chalk.dim(`could not release the build slot: ${err?.message || err}`)));
+		}
+	};
+	const phase = (label, text) => out(phaseLine(label, text));
+	const stats = createRunRecorder({
+		platform: PLATFORM,
+		write: recordStats,
+		now,
+		note: (line) => out(phaseLine("stats", chalk.dim(line)))
+	});
+	const recordRun = stats.record;
+	let ccacheActivity = CCACHE_NOT_RUN;
+	const fail = (code, message, remedy, { lastBuildStatus = false, diagnostics = [], lines = [], logPath = null, lease } = {}) => {
+		if (lastBuildStatus) persistLastBuild({
+			writeState,
+			root,
+			record,
+			startedAt,
+			durationMs: now() - started,
+			status: "failed",
+			errorCode: code,
+			out
+		});
+		out(phaseLine("error", chalk.red(`${code}: ${message}`)));
+		for (const diagnostic of diagnostics) out(phaseLine("error", chalk.red(diagnostic)));
+		for (const line of lines) out(phaseLine("", chalk.dim(line)));
+		if (remedy) out(phaseLine("remedy", remedy));
+		if (logPath) out(phaseLine("log", logPath));
+		recordRun({
+			failed: true,
+			durationMs: now() - started
+		});
+		if (json) emit(JSON.stringify({
+			code,
+			message,
+			remedy: remedy ?? null,
+			...ccacheActivity.status === "not-run" ? {} : { ccache: ccacheActivity },
+			...lease === void 0 ? {} : { lease }
+		}));
+		writer.close();
+		return {
+			ok: false,
+			error: {
+				code,
+				message,
+				remedy: remedy ?? null
+			}
+		};
+	};
+	const settingsRepoRoot = repoRoot(root);
+	const settingsRoot = root;
+	const settingsContext = {
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: settingsRepoRoot
+	};
+	const projectKey = statsProjectKey({
+		root,
+		commonDir: settingsContext.gitCommonDir,
+		repoRoot: settingsRepoRoot
+	});
+	stats.setProject(projectKey);
+	let estimatesRead = null;
+	const estimates = () => estimatesRead ??= readEstimates({
+		projectKey,
+		platform: PLATFORM
+	});
+	const settings = resolveSettingsFor(settingsContext);
+	const [shapeError, ...moreShapeErrors] = [parkedMaxSetting("android").error, ...settingShapeErrors(settings)].filter((error) => Boolean(error));
+	if (shapeError) return fail("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY, { lines: moreShapeErrors });
+	for (const key of unknownSettingKeys(settings)) out(phaseLine("setting", chalk.yellow(`Warning: setting "${key}" is not read by Stim and will be ignored.`)));
+	let optimizations;
+	try {
+		optimizations = resolveOptimizations(settings);
+	} catch (error) {
+		return fail("STIM_BAD_ARG", `Could not configure Android build: ${error.message}`, SETTING_SHAPE_REMEDY);
+	}
+	const compilerCache = androidCompilerCache({
+		root,
+		optimizations,
+		settingsContext
+	});
+	const cas = compilerCache.cas;
+	optimizations = compilerCache.optimizations;
+	if (compilerCache.warning) out(phaseLine("cache", chalk.yellow(compilerCache.warning)));
+	const buildProfile = optimizationBuildProfile("android", optimizations);
+	const cacheProviderConfig = resolveCacheProvider(settingsContext);
+	const cacheProviderError = cacheProviderSettingError(settings);
+	if (cacheProviderError) out(phaseLine("cache", chalk.yellow(`${cacheProviderError} Using the local cache.`)));
+	const dataPartitionSizeError = androidDataPartitionSizeGbSettingError(settings);
+	if (dataPartitionSizeError) return fail("STIM_BAD_ARG", dataPartitionSizeError, "Set android.dataPartitionSizeGb to a whole number of GiB from 6 through 16384.");
+	const avdConfigError = androidAvdConfigSettingError(settings, settingsRoot);
+	if (avdConfigError) return fail("STIM_BAD_ARG", avdConfigError, "Use only documented android.avdConfig keys, or an android.avdConfigFile fragment contained by the app directory.");
+	const remoteSettingError = remoteDeviceSettingError(settings);
+	if (remoteSettingError) return fail("STIM_BAD_ARG", remoteSettingError, `Set ios.remote and android.remote to one of: ${REMOTE_DEVICE_BACKENDS.join(", ")}.`);
+	const systemImage = resolveSystemImage(systemImageFlag, settings);
+	const variant = resolveVariant(variantFlag, settings);
+	const flavorRefusal = productFlavorRefusal({
+		flavors: readProductFlavors(root),
+		variant
+	});
+	if (flavorRefusal) return fail(flavorRefusal.code, flavorRefusal.reason, flavorRefusal.remedy);
+	const release = isReleaseVariant(variant);
+	const cachePolicy = artifactCachePolicy(optimizations, requestedBuildCache, release);
+	const useBuildCache = cachePolicy.read;
+	const isExpo = detectIsExpo(root);
+	const physical = deviceFlag !== null && deviceFlag !== void 0 && deviceFlag !== false;
+	if (physical && deviceFlag === "") return fail("STIM_BAD_ARG", "--device was given an empty serial.", "Pass `--device` on its own to take the first connected device this workspace can lease, or `--device <serial>` to name one.");
+	if (physical && commandRemoteBackend) return fail("STIM_BAD_ARG", "--device installs on a device connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote.");
+	const noWait = waitFlag === false;
+	const waitFlagged = waitFlag !== void 0;
+	if (waitConflict) return fail("STIM_BAD_ARG", "--wait and --no-wait ask for opposite things.", "Pass `--wait <seconds>` to wait for the lease, or `--no-wait` to install without one.");
+	if (waitFlagged && !physical) return fail("STIM_BAD_ARG", "--wait and --no-wait only apply to a `--device` run.", "This workspace owns its emulator, so nothing contends for it. Drop the flag, or pass `--device`.");
+	const waitParsed = parseDeviceWait(noWait ? void 0 : waitFlag);
+	if ("error" in waitParsed) return fail("STIM_BAD_ARG", waitParsed.error, "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a leased device at once.");
+	const waitSeconds = waitParsed.seconds;
+	const remoteBackend = physical ? null : commandRemoteBackend ?? remoteAndroidSetting(settings);
+	const imageRefusal = systemImageRefusal({
+		flag: systemImageFlag,
+		resolved: systemImage,
+		physical,
+		remoteBackend,
+		listImages: listSystemImages
+	});
+	if (imageRefusal) return fail(imageRefusal.code, imageRefusal.message, imageRefusal.remedy);
+	const requestedSerial = typeof deviceFlag === "string" ? deviceFlag : null;
+	let androidPackage = detectAndroidPackage(root);
+	record.bundleId = androidPackage;
+	const registerProject = () => upsertProject(root, {
+		bundleId: detectBundleId(root) ?? void 0,
+		androidPackage: androidPackage ?? void 0,
+		isExpo
+	});
+	if (remoteBackend !== "eas") registerProject();
+	const project = getProject(root);
+	const label = projectShortcut(root, project);
+	let remoteDevice = null;
+	const reservedPort = project?.metroPort ?? null;
+	let metroPort = null;
+	let phaseFailure = null;
+	async function resolveMetroPort() {
+		if (release) phase("metro", `skipped (${variant}: the JS bundle is embedded, no dev server is used)`);
+		else if (metroCheck) {
+			if (!reservedPort) {
+				phaseFailure = fail(NO_METRO, "No Metro port is reserved for this workspace.", "Run `stim start` first, or pass --no-metro-check.");
+				return false;
+			}
+			const held = await resolveMetroRetrying(resolveMetro, reservedPort, root, { onRetry: ({ delayMs }) => phase("metro", `port ${reservedPort} did not verify yet; retrying in ${Math.round(delayMs / 1e3)}s (Metro may still be indexing)`) });
+			if (!held.metro) {
+				const supervisor = readState(root)?.supervisor ?? null;
+				const supervisorAlive = Boolean(supervisor?.pid && pidAlive(supervisor.pid));
+				phaseFailure = fail(NO_METRO, noMetroMessage({
+					port: reservedPort,
+					resolution: held,
+					supervisor,
+					supervisorAlive
+				}), noMetroRemedy({
+					port: reservedPort,
+					supervisor,
+					supervisorAlive
+				}));
+				return false;
+			}
+			phase("metro", `port ${reservedPort} (pid ${held.metro?.pid})`);
+		} else phase("metro", reservedPort ? `port ${reservedPort} (not checked)` : `no reservation; using ${DEFAULT_METRO_PORT} (not checked)`);
+		metroPort = release ? null : reservedPort ?? 8081;
+		return true;
+	}
+	if (!await resolveMetroPort()) return phaseFailure;
+	if (remoteBackend) {
+		const resolved = await resolveRemoteDeviceContext({
+			root,
+			label,
+			platform: PLATFORM,
+			backend: remoteBackend,
+			easBin: resolveEasBin(root)?.file ?? null
+		});
+		if ("failed" in resolved) return fail(resolved.code ?? "STIM_NO_REMOTE_SESSION", resolved.failed, resolved.remedy);
+		remoteDevice = makeRemoteDeviceDeps(resolved.ctx);
+		if (metroPort !== null) {
+			const reachable = await ensureRemoteMetro({
+				ctx: remoteDevice.ctx,
+				metroPort,
+				isExpo,
+				tunnelMode: tunnelModeSetting(settings) ?? void 0,
+				publicUrl: publicUrlSetting(settings),
+				available: detectRemoteProviders(binOnPath)
+			});
+			if ("failed" in reachable) return fail(reachable.code ?? "STIM_NO_REMOTE_SESSION", reachable.failed, reachable.remedy);
+		}
+		checkCapacity = remoteDevice.checkCapacity;
+		ensureDevice = remoteDevice.ensureDevice;
+		ensureDeviceBooted = remoteDevice.ensureDeviceBooted;
+		install = remoteDevice.install;
+		launch = remoteDevice.launch;
+	}
+	const emuLog = emulatorLogFile(root);
+	const limits = getLimits();
+	let device;
+	let bootDuration = "";
+	let bootPromise;
+	if (physical && !requestedSerial) {
+		const pooled = await pooledAndroidDevice({
+			root,
+			selectPool,
+			listDevices,
+			isEmulatorDevice,
+			deviceModel,
+			waitSeconds,
+			noWait,
+			now,
+			warn: (line) => out(phaseLine("lease", chalk.yellow(line)))
+		});
+		if ("code" in pooled) return fail(pooled.code, pooled.message, pooled.remedy, pooled.extra);
+		device = pooled.device;
+		bootPromise = Promise.resolve({
+			ok: true,
+			serial: pooled.device.serial
+		});
+	} else if (physical) {
+		const resolved = resolvePhysicalDevice(requestedSerial, listDevices(), isEmulatorDevice);
+		if (!resolved.serial) return fail(NO_DEVICE, resolved.error, resolved.remedy);
+		device = {
+			serial: resolved.serial,
+			deviceName: deviceModel(resolved.serial) ?? resolved.serial,
+			owned: false
+		};
+		bootPromise = Promise.resolve({
+			ok: true,
+			serial: resolved.serial
+		});
+	} else {
+		const capacity = checkCapacity({
+			platform: PLATFORM,
+			project,
+			max: limits.maxDevices
+		});
+		if (capacity) return fail(capacity.code, capacity.message, capacity.remedy);
+		const prepare = stepClock(now);
+		try {
+			device = await ensureDevice({
+				platform: PLATFORM,
+				project,
+				projectPath: root,
+				settingsRoot,
+				settings,
+				flags: { systemImage },
+				note: out,
+				out,
+				logFile: emuLog
+			});
+		} catch (err) {
+			const diag = noDeviceDiagnostic({
+				reason: `Could not ensure an owned Android emulator: ${err?.message || err}`,
+				logFile: emuLog,
+				remedy: "Check that JAVA_HOME and ANDROID_HOME are set correctly, and that an arm64 system image is installed (`sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`)."
+			});
+			return fail(NO_DEVICE, diag.message, diag.remedy, {
+				lines: diag.lines,
+				logPath: diag.logPath ? displayPath(root, diag.logPath) : null
+			});
+		}
+		const prepareMs = prepare();
+		if (device.created || prepareMs >= 2e3) phase("device", `${device.avdName || device.deviceName || label} ${device.created ? "created" : "prepared"} (${formatDuration(prepareMs)})`);
+		const bootTimer = stepTimer(now);
+		const boot = () => Promise.resolve(ensureDeviceBooted({
+			platform: PLATFORM,
+			device,
+			out,
+			logFile: emuLog
+		})).catch((e) => ({
+			failed: true,
+			reason: String(e?.message || e),
+			serial: void 0
+		}));
+		bootPromise = (remoteDevice?.ctx.backend === "eas" ? ensureRemoteOwned({
+			root,
+			platform: PLATFORM,
+			sessionName: ownedSessionName(remoteDevice.ctx.label),
+			startedAt,
+			boot,
+			createdSessionId: remoteDevice.createdSessionId,
+			abandonCreatedSession: remoteDevice.abandonCreatedSession,
+			writeState,
+			register: registerProject
+		}) : boot()).then((result) => {
+			bootDuration = bootTimer();
+			return result;
+		});
+	}
+	if (remoteDevice) {
+		const booted = await bootPromise;
+		if (booted.failed) {
+			if (booted.code) return fail(booted.code, booted.reason ?? "The remote device did not boot.", booted.remedy ?? null);
+			const diag = noDeviceDiagnostic({
+				reason: booted.reason ?? "The remote device did not boot.",
+				logFile: emuLog,
+				remedy: "Run `stim status` to inspect the remote device, then retry the command.",
+				localEmulator: false
+			});
+			return fail(NO_DEVICE, diag.message, diag.remedy, {
+				lines: diag.lines,
+				logPath: diag.logPath ? displayPath(root, diag.logPath) : null
+			});
+		}
+	}
+	record.avdName = device.avdName ?? null;
+	record.deviceName = device.deviceName ?? device.avdName ?? null;
+	record.systemImage = device.systemImage;
+	const { abi: buildAbi, runOptions: buildRunOptions, remoteRunOptions } = androidBuildOptions({
+		release,
+		physical,
+		device,
+		variant,
+		deviceAbi,
+		compiler: cas?.id,
+		buildProfile,
+		targetAbiOnly: optimizations.android.targetAbiOnly
+	});
+	let hash = "";
+	let providerUpload = null;
+	let providerName = null;
+	let providerLoad = null;
+	const cacheWarn = createWarnOnce((line) => phase("cache", chalk.yellow(line)));
+	const loadTieredProvider = cachePolicy.remote && cacheProviderConfig ? () => providerLoad ??= loadCacheProviderModule({
+		projectRoot: root,
+		config: cacheProviderConfig
+	}) : null;
+	let fingerprintSources = [];
+	let cacheKey = "";
+	let storeHash = "";
+	let storeKey = "";
+	let storeSources = [];
+	let apkPath = null;
+	async function resolveInitialFingerprint() {
+		const fingerprintTimer = stepTimer(now);
+		try {
+			const computed = await fingerprint(root, { platform: PLATFORM });
+			hash = computed?.hash ?? "";
+			fingerprintSources = computed?.sources ?? [];
+		} catch (err) {
+			phaseFailure = fail(NO_FINGERPRINT, `@expo/fingerprint could not fingerprint ${root}: ${err?.message || err}`, "Fix the @expo/fingerprint error above, then retry.");
+			return false;
+		}
+		if (!hash) {
+			phaseFailure = fail(NO_FINGERPRINT, `@expo/fingerprint returned no hash for ${root}, so the build cache cannot be addressed.`, "Check the project native inputs and the @expo/fingerprint error above, then retry.");
+			return false;
+		}
+		record.fingerprint = hash;
+		cacheKey = buildCacheKey(PLATFORM, hash, buildRunOptions);
+		stats.setCacheKey(cacheKey);
+		record.cacheKey = cacheKey;
+		storeHash = hash;
+		storeKey = cacheKey;
+		storeSources = fingerprintSources;
+		const found = await resolveTieredBuild({
+			local: filesystemBuildCapability({
+				resolve: resolveCached,
+				store: storeCached,
+				sources: fingerprintSources
+			}),
+			loadProvider: loadTieredProvider,
+			target: {
+				projectRoot: root,
+				platform: PLATFORM,
+				key: cacheKey
+			},
+			destinationDir: providerDownloadPath(workspaceDir(root)),
+			ensureDestination: prepareProviderDownloadDir,
+			skipRead: !useBuildCache,
+			warn: cacheWarn
+		});
+		const cached = found?.tier === "local" ? found.path : null;
+		record.cacheHit = cached ? "local" : false;
+		record.cacheSkipped = !useBuildCache;
+		let missDiff = "";
+		let missUntracked = null;
+		if (!cached) {
+			const lastBuild = readState(root)?.lastBuild ?? null;
+			const miss = describeFingerprintMiss({
+				platform: PLATFORM,
+				current: {
+					hash,
+					sources: fingerprintSources
+				},
+				lastBuild
+			});
+			if (miss) {
+				missDiff = fingerprintDiffSuffix(miss.changed);
+				writer.write(fingerprintDiffRecord({
+					changed: miss.changed,
+					previousHash: miss.previousHash,
+					hash
+				}));
+			} else if (useBuildCache) missUntracked = untrackedMissLine(untracked({ projectRoot: root }));
+		}
+		phase("fingerprint", `${shortHash(hash)} ${cached ? "hit" : "miss"}${useBuildCache ? "" : !requestedBuildCache ? " (--no-build-cache)" : " (cache reuse off in config)"} ${fingerprintTimer()}${missDiff}`);
+		if (missUntracked) phase("fingerprint", chalk.dim(missUntracked));
+		if (found?.tier === "provider") {
+			record.cacheHit = "remote";
+			providerName = found.providerName ?? null;
+			phase("cache", `provider hit (${providerName})${found.storedLocally ? " -> stored locally" : ""}`);
+		}
+		apkPath = found?.path ?? null;
+		return true;
+	}
+	const runFromFingerprint = async () => {
+		if (!await resolveInitialFingerprint()) return phaseFailure;
+		let remote = null;
+		let abandonedRemote = false;
+		let uploadPending = null;
+		async function resolveRemoteArtifact() {
+			if (buildAbi || cas || buildProfile || !cachePolicy.remote) return;
+			if (!apkPath) {
+				const loaded = await loadProvider(root, { isExpo });
+				if (loaded?.unavailable) phase("cache", chalk.yellow(`provider not usable: ${loaded.unavailable}`));
+				else if (loaded?.provider) remote = loaded;
+				if (remote?.name === "eas") {
+					const auth = easAuth({
+						projectRoot: root,
+						owner: loaded?.owner || null
+					});
+					const authNote = easAuthNote(auth);
+					if (authNote) phase("cache", chalk.yellow(authNote));
+					if (auth?.code === "logged-out") remote = null;
+				}
+			}
+			if (remote && useBuildCache) {
+				const remoteTimer = stepTimer(now);
+				const hit = await resolveRemoteBuild({
+					logWriter: writer,
+					provider: remote.provider,
+					platform: PLATFORM,
+					projectRoot: root,
+					fingerprintHash: hash,
+					runOptions: remoteRunOptions
+				});
+				if (hit?.appPath) {
+					let stored = null;
+					try {
+						stored = storeCached(PLATFORM, cacheKey, hit.appPath, { sources: fingerprintSources });
+					} catch (err) {
+						phase("cache", chalk.yellow(`remote hit could not be stored locally: ${err?.message || err}`));
+					}
+					apkPath = stored || hit.appPath;
+					record.cacheHit = "remote";
+					phase("cache", `remote hit (${remote.name})${stored ? " -> stored locally" : ""} ${remoteTimer()}`);
+				} else if (hit?.timedOut) {
+					abandonedRemote = true;
+					phase("cache", chalk.yellow(`${remote.name} did not answer within ${formatDuration(RESOLVE_TIMEOUT_MS)}; building instead`));
+				} else if (hit?.failed) {
+					const authNote = remote.name === "eas" && isEasAuthFailureText(hit.failed) ? easAuthNote({
+						code: "logged-out",
+						reason: hit.failed
+					}) : null;
+					phase("cache", chalk.yellow(authNote || `${remote.name} could not be used: ${hit.failed}; building instead`));
+				} else phase("cache", `remote miss (${remote.name}) ${remoteTimer()}`);
+			}
+		}
+		await resolveRemoteArtifact();
+		let waitedForBuild = null;
+		let releasedWait = null;
+		async function waitForSharedBuild() {
+			if (!useBuildCache) return true;
+			const waitStarted = now();
+			let failedHolder;
+			while (!apkPath) {
+				let attempt = null;
+				try {
+					attempt = acquireLock({
+						platform: PLATFORM,
+						key: cacheKey,
+						root,
+						logFile: buildLog
+					});
+				} catch (err) {
+					const refusal = claimFailure(err, "stim android");
+					if (refusal) {
+						phaseFailure = fail(refusal.code, refusal.message, refusal.remedy, { lastBuildStatus: true });
+						return false;
+					}
+					phase("build", chalk.yellow(`could not take the build lock: ${err?.message || err}; building anyway`));
+				}
+				if (attempt?.acquired) {
+					buildLock = attempt;
+					const previous = attempt.tookOver ?? failedHolder;
+					if (previous) phase("build", chalk.yellow(takeoverLine(previous)));
+					break;
+				} else if (attempt?.held) {
+					releasedWait = null;
+					const holder = attempt.held;
+					const who = holder.projectRoot || "another workspace";
+					phase("build", `${who} is already building ${shortHash(hash)} (pid ${holder.pid})${holder.logFile ? ` -- tail ${holder.logFile}` : ""}`);
+					let waited = null;
+					try {
+						const ceilingMs = WAIT_CEILING_MS - (now() - waitStarted);
+						if (ceilingMs <= 0) throw Object.assign(/* @__PURE__ */ new Error(`Waited ${formatDuration(now() - waitStarted)} for shared builds without an artifact; ${who} (pid ${holder.pid}) holds ${attempt.path}.`), {
+							code: "STIM_BUILD_WAIT_TIMEOUT",
+							lockPath: attempt.path
+						});
+						waited = await waitForBuild({
+							platform: PLATFORM,
+							key: cacheKey,
+							out,
+							ceilingMs
+						});
+					} catch (err) {
+						const refusal = claimFailure(err, "stim android");
+						if (refusal) {
+							phaseFailure = fail(refusal.code, refusal.message, refusal.remedy, { lastBuildStatus: true });
+							return false;
+						}
+						const wtErr = err;
+						if (wtErr?.code !== "STIM_BUILD_WAIT_TIMEOUT") throw err;
+						phaseFailure = fail("STIM_BUILD_WAIT_TIMEOUT", wtErr.message, `Check pid ${holder.pid}; if it is not really building, remove ${wtErr.lockPath} and run \`stim android\` again.`, { lastBuildStatus: true });
+						return false;
+					}
+					if (waited?.hit) {
+						apkPath = waited.hit ?? null;
+						record.cacheHit = "local";
+						waitedForBuild = {
+							pid: holder.pid,
+							ms: waited.waitedMs
+						};
+						phase("build", `waited ${formatDuration(waited.waitedMs)} for ${who}'s build -> installed from cache`);
+					} else if (waited?.lockReleased) {
+						failedHolder = void 0;
+						releasedWait = {
+							facts: {
+								pid: holder.pid,
+								ms: waited.waitedMs
+							},
+							who
+						};
+						phase("build", `${who}'s build lock was released; rechecking this workspace before building`);
+					} else {
+						phase("build", chalk.yellow(`${who}'s build ended without an artifact (${waited?.builderFailed}); retrying the build lock`));
+						failedHolder = holder;
+					}
+				} else break;
+			}
+			return true;
+		}
+		if (!await waitForSharedBuild()) return phaseFailure;
+		let swapDir = null;
+		let swapFellBack = false;
+		const installableCachedApk = async (key, cachedPath) => {
+			if (!release) return cachedPath;
+			phase("swap", `regenerating this workspace's JS for the cached ${variant} APK`);
+			const swap = await swapApk({
+				root,
+				isExpo,
+				cachedApkPath: cachedPath,
+				keystore: resolveKeystore(root, settings),
+				logWriter: writer,
+				storedAssets: storedAssets(PLATFORM, key)
+			});
+			if (swap?.ok && swap.apkPath) {
+				if (swap.note) phase("swap", chalk.yellow(swap.note));
+				swapDir = swap.tmpDir ?? null;
+				phase("swap", `${swap.hermes ? "hermes bytecode" : "plain JS"} repacked (store), zipaligned and re-signed (${formatDuration(swap.durationMs)})`);
+				return swap.apkPath;
+			}
+			if (swap?.assetMismatch) phase("swap", chalk.yellow(`${swap.reason} -- building fresh instead` + (swap.assetDiff ? " (an APK cannot be made to carry an asset AAPT did not package)" : "")));
+			else phase("swap", chalk.yellow(`failed at ${swap?.step || "unknown step"}: ${swap?.reason || "unknown reason"} -- building fresh instead (a cached ${variant} APK carries its builder's JS; it is never installed after a failed swap)`));
+			for (const line of swap?.lastLines ?? []) phase("", chalk.dim(line));
+			swapFellBack = true;
+			return null;
+		};
+		async function prepareCachedArtifact() {
+			if (apkPath && record.cacheHit) {
+				const prepared = await installableCachedApk(cacheKey, apkPath);
+				apkPath = prepared;
+				if (!prepared) {
+					record.cacheHit = false;
+					waitedForBuild = null;
+				}
+			}
+		}
+		async function buildArtifact() {
+			if (!apkPath) try {
+				if (limits.maxBuilds) try {
+					buildSlot = await acquireSlot({
+						max: limits.maxBuilds,
+						root,
+						logFile: buildLog,
+						out
+					});
+				} catch (err) {
+					const refusal = claimFailure(err, "stim android");
+					if (refusal) {
+						phaseFailure = fail(refusal.code, refusal.message, refusal.remedy, { lastBuildStatus: true });
+						return false;
+					}
+					phase("build", chalk.yellow(`could not take a build slot: ${err?.message || err}; building anyway`));
+				}
+				if (needsPrebuildFor(root, "android", isExpo)) {
+					const pre = await prebuild(root, PLATFORM, writer, { isExpo });
+					if (pre.failed) {
+						phaseFailure = fail(pre.code, pre.reason, pre.remedy, {
+							lastBuildStatus: true,
+							lines: tail(pre.lastLines),
+							logPath: displayPath(root, buildLog)
+						});
+						return false;
+					}
+					phase("prebuild", `android/ generated (${formatDuration(pre.durationMs)})`);
+					androidPackage = androidPackage || detectAndroidPackage(root);
+					record.bundleId = androidPackage;
+					const after = await refingerprintAfterMutation({
+						projectRoot: root,
+						platform: PLATFORM,
+						previousHash: hash,
+						fingerprint
+					});
+					if (after?.moved) {
+						storeHash = after.hash;
+						storeSources = after.sources;
+						storeKey = buildCacheKey(PLATFORM, after.hash, buildRunOptions);
+						record.fingerprint = storeHash;
+						record.cacheKey = storeKey;
+						phase("fingerprint", chalk.dim(`${shortHash(hash)} -> ${shortHash(storeHash)} (after prebuild)`));
+						const late = useBuildCache ? resolveCached(PLATFORM, storeKey) : null;
+						if (late) {
+							const prepared = await installableCachedApk(storeKey, late);
+							if (prepared) {
+								apkPath = prepared;
+								record.cacheHit = "local";
+								phase("cache", `hit ${shortHash(storeHash)} (post-prebuild key)`);
+								if (releasedWait) {
+									waitedForBuild = releasedWait.facts;
+									phase("build", `waited ${formatDuration(waitedForBuild.ms)} for ${releasedWait.who}'s build -> installed from cache`);
+								}
+							}
+						}
+					}
+				}
+				if (!apkPath) {
+					phase("build", `compiling ${variant || "debug"} with Gradle`);
+					const built = await build({
+						root,
+						logWriter: writer,
+						variant,
+						abi: buildAbi
+					}, {
+						estimateMs: estimates().coldBuildMs,
+						ccache: optimizations.android.compilerCache === "ccache" ? ccacheFor({
+							root,
+							onNote: out
+						}) : null,
+						cas,
+						buildCache: optimizations.android.gradleBuildCache,
+						pch: optimizations.android.pch,
+						compilerCacheDisabled: optimizations.android.compilerCache === "none"
+					});
+					ccacheActivity = built.ccache ?? CCACHE_UNAVAILABLE;
+					phase("cache", `compilation cache ${ccacheActivityLine(ccacheActivity)}`);
+					if (built.failed) {
+						const diagnostics = built.diagnostics || [];
+						for (const diag of diagnostics) writer.write({
+							src: "build",
+							level: "error",
+							event: "gradle_diagnostic",
+							msg: formatDiagnostic(diag)
+						});
+						phase("build", chalk.red(`FAILED after ${formatDuration(built.durationMs)}`));
+						const extracted = diagnostics.map(formatDiagnostic);
+						if ((built.truncated ?? 0) > 0) extracted.push(`... and ${built.truncated} more diagnostic(s) in the log`);
+						phaseFailure = fail(built.code, built.reason, diagnostics.find((d) => d.remedy)?.remedy || built.remedy || null, {
+							lastBuildStatus: true,
+							diagnostics: extracted,
+							lines: extracted.length ? [] : tail(built.lastLines),
+							logPath: displayPath(root, buildLog)
+						});
+						return false;
+					}
+					apkPath = built.apkPath ?? null;
+					stats.setBuildMs(built.durationMs ?? 0);
+					phase("build", `ok (${formatDuration(built.durationMs)})`);
+					if (built.apkNote) phase("build", chalk.yellow(built.apkNote));
+					const beforeBuildHash = storeHash;
+					const afterBuild = await refingerprintAfterMutation({
+						projectRoot: root,
+						platform: PLATFORM,
+						previousHash: beforeBuildHash,
+						fingerprint
+					});
+					if (!afterBuild) {
+						record.fingerprint = null;
+						record.cacheKey = null;
+						phase("fingerprint", chalk.yellow("unavailable after Gradle; the build will be installed but not cached"));
+					} else {
+						if (afterBuild.moved) {
+							storeHash = afterBuild.hash;
+							storeSources = afterBuild.sources;
+							storeKey = buildCacheKey(PLATFORM, afterBuild.hash, buildRunOptions);
+							record.fingerprint = storeHash;
+							record.cacheKey = storeKey;
+							phase("fingerprint", chalk.dim(`${shortHash(beforeBuildHash)} -> ${shortHash(storeHash)} (after Gradle)`));
+						}
+						if (cachePolicy.write) {
+							const assetManifest = release ? captureAssets(root, { variant }) : null;
+							try {
+								const stored = await storeTieredBuild({
+									local: filesystemBuildCapability({
+										resolve: resolveCached,
+										store: storeCached,
+										sources: storeSources,
+										assetManifest
+									}),
+									loadProvider: loadTieredProvider,
+									target: {
+										projectRoot: root,
+										platform: PLATFORM,
+										key: storeKey
+									},
+									sourcePath: apkPath,
+									overwrite: !useBuildCache || swapFellBack,
+									warn: cacheWarn
+								});
+								providerUpload = stored.providerUpload;
+								providerName = stored.providerName ?? providerName;
+							} catch (err) {
+								phase("cache", chalk.yellow(`could not store the build: ${err?.message || err}`));
+							}
+						}
+						if (remote) uploadPending = uploadRemoteBuild({
+							logWriter: writer,
+							provider: remote.provider,
+							platform: PLATFORM,
+							projectRoot: root,
+							fingerprintHash: storeHash,
+							buildPath: apkPath,
+							runOptions: remoteRunOptions
+						});
+					}
+				}
+			} finally {
+				releaseHeldLock();
+				releaseHeldSlot();
+			}
+			return true;
+		}
+		await prepareCachedArtifact();
+		if (!await buildArtifact()) return phaseFailure;
+		record.appPath = apkPath;
+		let leaseHandle = null;
+		let stopLeaseSignals = null;
+		const releaseLease = () => {
+			const held = leaseHandle;
+			const stopSignals = stopLeaseSignals;
+			leaseHandle = null;
+			stopLeaseSignals = null;
+			stopSignals?.();
+			try {
+				held?.release();
+			} catch (err) {
+				out(phaseLine("lease", chalk.dim(`could not release this run's lease: ${err?.message || err}`)));
+			}
+		};
+		if (physical) {
+			const acquired = await acquireLease({
+				root,
+				platform: PLATFORM,
+				id: device.serial,
+				deviceName: device.deviceName ?? null,
+				idLabel: "serial",
+				waitSeconds,
+				noWait,
+				installBoundMs: ADB_INSTALL_TIMEOUT_MS,
+				appId: androidPackage,
+				holderAppId: (holder) => getProject(holder)?.androidPackage ?? null,
+				now,
+				warn: (line) => out(phaseLine("lease", chalk.yellow(line)))
+			});
+			if (acquired.status === "refused") return fail(acquired.refusal.code, acquired.refusal.message, acquired.refusal.remedy, { lease: acquired.refusal.lease });
+			leaseHandle = makeRunLease({
+				root,
+				platform: PLATFORM,
+				kind: acquired.status === "leased" ? acquired.kind : null,
+				expiresAt: acquired.status === "leased" ? acquired.expiresAt : null
+			});
+			if (acquired.status === "leased") {
+				stopLeaseSignals = onLeaseSignal(releaseLease);
+				phase("lease", `${acquired.kind} lease on ${device.serial} until ${leaseExpiryText(acquired.expiresAt, now())}`);
+			}
+		}
+		try {
+			return await finishAndroidRun({
+				lease: leaseHandle,
+				releaseLease,
+				root,
+				json,
+				metroCheck,
+				useBuildCache,
+				variant,
+				release,
+				isExpo,
+				metroPort,
+				logsDir,
+				emuLog,
+				device,
+				physical,
+				remoteDevice,
+				bootPromise,
+				bootDuration: () => bootDuration,
+				apkPath,
+				androidPackage,
+				swapDir,
+				record,
+				waitedForBuild,
+				ccache: ccacheActivity,
+				uploadPending,
+				providerUpload,
+				providerName,
+				remote,
+				abandonedRemote,
+				started,
+				startedAt,
+				writer,
+				phase,
+				fail,
+				readApkPackage,
+				install,
+				launch,
+				launchRelease,
+				resolveDevClientScheme,
+				verifyLaunched,
+				verifyReleaseLaunched,
+				spawn,
+				kill,
+				pidAlive,
+				verifyCollector,
+				writeLaunch,
+				writeState,
+				now,
+				out,
+				emit,
+				recordRun
+			});
+		} finally {
+			releaseLease();
+		}
+	};
+	try {
+		return await runFromFingerprint();
+	} catch (error) {
+		recordRun({
+			failed: true,
+			durationMs: now() - started
+		});
+		throw error;
+	}
+}
+function tail(lines, n = FALLBACK_LINES) {
+	return (Array.isArray(lines) ? lines : []).slice(-n);
+}
+//#endregion
+export { NO_DEVICE, NO_FINGERPRINT, NO_METRO, androidDevClientScheme, androidFacts, androidSystemImageSetting, androidVariantSetting, apkDevClientFacts, apkPackage, collectorLogFile, androidCommand as default, displayPath, dumpApkManifest, findAapt, formatDuration, isReleaseVariant, killPreviousCollector, lastBuildRecord, noDeviceDiagnostic, parseXmltree, phaseLine, registerAndroid, resolveSystemImage, resolveVariant, runAndroid, shortHash, startCollector };