stim 1.19.0 → 1.20.0

package/dist/react-native-android-chm1DMlA.mjs

@@ -0,0 +1,921 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { W as validateDeviceSlot, p as getProject, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { Ft as removeTemporaryEntry, L as publicUrlSetting, Pt as makeTemporaryDirectory, U as resolveAndroidLayout, V as remoteEasFallbackSetting, Z as settingOriginScope, et as settingsLayers, m as defaultAndroidLayout, tt as tunnelModeSetting, z as realpathInside } from "./settings-Bbztm4oV.mjs";
+import { B as captureAssetManifest, D as fingerprintProject, E as fingerprintDiffRecord, F as storedAssetManifest, H as readAssetManifest, L as untrackedMissLine, M as refingerprintAfterMutation, N as resolveBuild, O as inputsChangedDuringBuild, P as storeBuild, R as untrackedNativeFiles, S as configInputsChanged, T as filesystemBuildCapability, V as compareAssetManifests, b as buildCacheKey, x as changedDuringBuildLine, z as assetDiffReason } from "./device-lease-DHOBXGgS.mjs";
+import { r as readWorkspaceState } from "./workspace-state-CSIFuuDa.mjs";
+import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BjPN99ZB.mjs";
+import { _ as detectIsExpo } from "./project-B8_duAzW.mjs";
+import { A as listAvds, B as ownedAvdSystemImage, D as hostSystemImageArch, I as ownedAvdDirectory, T as findBuildTool, W as pickDefaultSystemImage, j as listInstalledSystemImages, l as androidSystemImageAbi, r as androidBuildToolName } from "./android-BsYNR81W.mjs";
+import { It as statsProjectKey } from "./budget-BONq9vXY.mjs";
+import { t as cleanLine } from "./server-expo-CsYu2aKL.mjs";
+import { c as loadProjectProvider, i as checkEasAuth, p as resolveRemote } from "./remote-cache-Bsts6f6Y.mjs";
+import { h as detectAppIds, m as detectAndroidPackage } from "./start-CdvcTaXr.mjs";
+import { n as fingerprintErrorMissReason, t as explainBuildMiss } from "./miss-reason-BPAzZS0r.mjs";
+import { o as resolveCcache } from "./ccache-CjHQ5F8g.mjs";
+import { M as startBuildHeartbeat, P as tailLines, n as androidToolchain, t as androidRequirements, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DqyDXs30.mjs";
+import { a as PLATFORM, c as androidGradleProject, h as displayPath, i as NO_FINGERPRINT, l as androidJobLayout, o as androidBuildOptions, r as NO_DEVICE } from "./support-CnE_SIjt.mjs";
+import { i as AndroidRecipeRefusal, r as resolveAndroidRunPlan } from "./plan-BDk2AeY_.mjs";
+import { c as readProductFlavors, n as buildAndroid, s as productFlavorRefusal } from "./react-native-build-oAw6gQeW.mjs";
+import { n as planFlagRefusal, o as checkEasFallback, r as planPayload, t as planCachedBuild } from "./build-plan-CP0tckNU.mjs";
+import { i as planEasDevelopmentBuild } from "./eas-build-Dw_ec2Km.mjs";
+import { n as androidProcessRuntime, t as androidMetroRuntime } from "./launch-DxH0THLP.mjs";
+import { i as staleNativeDirRefusal, n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-Bw44QxVh.mjs";
+import { n as detectEntryFile, r as refreshUpdatesManifestFile, t as UPDATES_MANIFEST_NAME } from "./js-swap-C8icNYIY.mjs";
+import { t as planHostedDevice } from "./plan-placement-D_YYlE6N.mjs";
+import { constants, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+import { loadCacheProvider } from "@stim-cli/cache";
+import chalk from "chalk";
+//#region src/engine/apk-swap.ts
+const ANDROID_BUNDLE_NAME = "index.android.bundle";
+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, { gradleRoot, moduleDir, custom } = defaultAndroidLayout(root)) {
+	for (const dir of custom ? [moduleDir, gradleRoot] : [gradleRoot]) {
+		let text;
+		try {
+			text = readFileSync(join(dir, "gradle.properties"), "utf-8");
+		} catch {
+			continue;
+		}
+		if (/^\s*hermesEnabled\s*[=:]/m.test(text)) return hermesEnabledFromGradleProperties(text);
+	}
+	return true;
+}
+function hermescBinDir(platform = process.platform) {
+	if (platform === "darwin") return "osx-bin";
+	return platform === "win32" ? "win64-bin" : "linux64-bin";
+}
+function hermescName(platform) {
+	return platform === "win32" ? "hermesc.exe" : "hermesc";
+}
+function hermescCandidates(root, { platform = process.platform, reactNativePath = null } = {}) {
+	const bin = hermescBinDir(platform);
+	const name = hermescName(platform);
+	const rn = reactNativePath ?? join(root, "node_modules", "react-native");
+	return [.../* @__PURE__ */ new Set([
+		join(dirname(rn), "hermes-compiler", "hermesc", bin, name),
+		join(root, "node_modules", "hermes-compiler", "hermesc", bin, name),
+		join(root, "node_modules", "react-native", "sdks", "hermesc", bin, name),
+		join(root, "node_modules", "react-native", "sdks", "hermes", "build", "bin", name)
+	])];
+}
+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 jarPath({ javaHome = process.env.JAVA_HOME } = {}) {
+	return javaHome ? join(javaHome, "bin", "jar") : "jar";
+}
+function zipalignArgs({ buildToolsMajor, input, output }) {
+	return [
+		...buildToolsMajor >= 35 ? ["-P", "16"] : ["-p"],
+		"-f",
+		"-v",
+		"4",
+		input,
+		output
+	];
+}
+const KEYSTORE_PASSWORD_ENV = "STIM_KEYSTORE_PASSWORD";
+function keystorePassArg(value) {
+	const text = typeof value === "string" ? value.trim() : "";
+	if (text === "") return {
+		pass: "pass:android",
+		password: null
+	};
+	if (/^(?:file|env):/.test(text) || text === "stdin") return {
+		pass: text,
+		password: null
+	};
+	return {
+		pass: `env:${KEYSTORE_PASSWORD_ENV}`,
+		password: text.startsWith("pass:") ? text.slice(5) : text
+	};
+}
+function resolveKeystore(root, settings, layout = defaultAndroidLayout(root), containedIn = null) {
+	const android = settings?.["android"];
+	const bag = android && typeof android === "object" && !Array.isArray(android) ? android : {};
+	const configured = bag["keystore"];
+	let path = typeof configured === "string" && configured.trim() !== "" ? isAbsolute(configured.trim()) ? configured.trim() : join(root, configured.trim()) : join(layout.moduleDir, "debug.keystore");
+	if (containedIn !== null && typeof configured === "string" && configured.trim() !== "") try {
+		path = realpathInside(containedIn, path);
+	} catch (error) {
+		throw new Error(`Could not use android.keystore ${configured.trim()} from the committed .stim.json: ${String(error?.message || error)}`, { cause: error });
+	}
+	return {
+		path,
+		...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, layout = defaultAndroidLayout(root), buildTools = null, findTool = findBuildTool, storedAssets = null, readManifest = readAssetManifest, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, onHeartbeat = (line) => console.error(line), platform = process.platform }) {
+	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);
+		copyApk(e, cachedApkPath, work, platform);
+	} 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, layout)) {
+		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
+				}));
+				renameSync(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);
+	const jar = jarPath();
+	const updatesManifest = join(stage, "assets", UPDATES_MANIFEST_NAME);
+	try {
+		e.runFile(jar, [
+			"--extract",
+			"--file",
+			work,
+			`assets/${UPDATES_MANIFEST_NAME}`
+		], { cwd: stage });
+		if (exists(updatesManifest)) refreshUpdatesManifestFile(updatesManifest, now());
+	} catch (err) {
+		return fail("updates", `could not refresh the expo-updates manifest from ${work}: ${describe(err)}`);
+	}
+	try {
+		e.runFile(jar, [
+			"--update",
+			"--file",
+			work,
+			"--no-compress",
+			"-C",
+			stage,
+			"assets"
+		]);
+	} catch (err) {
+		return fail("zip", `${jar} --update ${work} 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), androidBuildToolName("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
+		}), keystore.password === null ? void 0 : {
+			env: { [KEYSTORE_PASSWORD_ENV]: keystore.password },
+			redact: [keystore.password]
+		});
+	} 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 copyApk(e, from, to, platform) {
+	if (platform === "darwin") try {
+		e.runFile("cp", [
+			"-c",
+			from,
+			to
+		]);
+		return;
+	} catch {}
+	copyFileSync(from, to, constants.COPYFILE_FICLONE);
+}
+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/integrations/react-native-android-plan.ts
+const DEFAULT_PLAN_DEPS = {
+	fingerprint: fingerprintProject,
+	listSystemImages: listInstalledSystemImages,
+	avdSystemImage: ownedAvdSystemImage,
+	avdDirectory: ownedAvdDirectory,
+	listAvds,
+	loadCacheProvider,
+	loadProjectProvider,
+	checkEasAuth,
+	resolveRemote,
+	planPrebuild
+};
+function note(line) {
+	console.error(line);
+}
+function refuse(refusal, lines = []) {
+	return {
+		refusal,
+		lines
+	};
+}
+function emulatorImage(root, slot, requested, deps) {
+	const record = deviceSlotPlatforms(getProject(root), slot)?.android;
+	if (record?.avdName && !record.setupIncomplete) {
+		if (record.owned && deps.avdDirectory(record.avdName)) return { systemImage: deps.avdSystemImage(record.avdName) };
+		if (!record.owned && avdListed(record.avdName, deps.listAvds)) return { systemImage: null };
+	}
+	let images;
+	try {
+		images = deps.listSystemImages();
+	} catch (error) {
+		return { refusal: {
+			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 picked = pickDefaultSystemImage(images, requested ? { systemImage: requested } : {});
+	if (picked) return { systemImage: picked.pkg };
+	const arch = hostSystemImageArch();
+	return { refusal: {
+		code: NO_DEVICE,
+		message: `No ${arch} Android system image is installed, so the emulator build's ABI and cache key are unknown.`,
+		remedy: `Install one, e.g.: sdkmanager "system-images;android-36;google_apis;${arch}", then try again.`
+	} };
+}
+function avdListed(avdName, list) {
+	try {
+		return list({ timeoutMs: 1e4 }).includes(avdName);
+	} catch {
+		return false;
+	}
+}
+async function planReactNativeAndroid(root, opts, runtimeKind, { context: settingsContext, settings }, layout, variantProblem, overrides = {}) {
+	const deps = {
+		...DEFAULT_PLAN_DEPS,
+		...overrides
+	};
+	const slot = validateDeviceSlot(opts.slot);
+	const planned = resolveAndroidRunPlan({
+		settings,
+		settingsContext,
+		slot,
+		easProfile: opts.easProfile,
+		variant: opts.variant ?? null,
+		systemImage: opts.systemImage ?? null,
+		device: null,
+		wait: void 0,
+		waitConflict: false,
+		remote: null,
+		buildCache: opts.buildCache !== false
+	}, {
+		runtimeKind,
+		variantProblem,
+		warn: (label, message) => note(phaseLine(label, chalk.yellow(message))),
+		resolveCompilerCache: ({ optimizations }) => ({
+			cas: null,
+			optimizations,
+			warning: null
+		}),
+		listSystemImages: deps.listSystemImages
+	});
+	if (!planned.ok) return refuse(planned, planned.lines);
+	const { build, target, isExpo, cacheProviderConfig } = planned.plan;
+	const planTarget = {
+		platform: PLATFORM,
+		slot,
+		root,
+		projectKey: statsProjectKey({
+			root,
+			commonDir: settingsContext.gitCommonDir,
+			repoRoot: settingsContext.repoRoot
+		})
+	};
+	if (opts.easProfile !== void 0) {
+		const eas = await planEasDevelopmentBuild({
+			root,
+			platform: PLATFORM,
+			profile: opts.easProfile,
+			note,
+			isExpo,
+			selectors: [opts.variant],
+			buildCache: opts.buildCache
+		});
+		if (!eas.ok) return refuse(eas);
+		return planPayload(planTarget, {
+			fingerprint: eas.fingerprint,
+			cacheKey: eas.cacheKey,
+			cacheHit: eas.buildId ? "remote" : false,
+			provider: "eas",
+			cacheSkipped: false,
+			prebuild: null,
+			refusal: eas.missing
+		});
+	}
+	if (target.kind === "physical") return refuse(planFlagRefusal("--device"));
+	if (target.kind === "remote") return refuse({
+		code: "STIM_BAD_ARG",
+		message: `android.remote is ${target.backend}, whose ABI --plan cannot read without a session.`,
+		remedy: "Run `stim android` to build for the remote device, or unset android.remote to plan the owned emulator."
+	});
+	if (build.compilerCache === "cas") return refuse({
+		code: "STIM_BAD_ARG",
+		message: "The experimental Android compiler CAS keys builds by a toolchain Stim sets up, which --plan does not.",
+		remedy: "Run `stim android` to build with the CAS, or set optimizations.android.compilerCache to ccache."
+	});
+	const abiKeyed = build.targetAbiOnly && !build.release;
+	const localImage = () => abiKeyed ? emulatorImage(root, slot, target.systemImage, deps) : { systemImage: null };
+	let image;
+	let hostedAbi = null;
+	let placement;
+	if (target.kind === "hosted") {
+		const hostedPlan = await planHostedDevice({
+			root,
+			slot,
+			platform: "android",
+			machine: target.machine,
+			selectors: {
+				...target.systemImage ? { systemImage: target.systemImage } : {},
+				...target.deviceProfile ? { deviceProfile: target.deviceProfile } : {}
+			},
+			sameKey: (choice) => {
+				if (build.targetAbiOnly && build.release) return !("architecture" in choice && choice.architecture);
+				if (!abiKeyed) return true;
+				const local = localImage();
+				if ("refusal" in local || !("systemImage" in choice)) return null;
+				return androidSystemImageAbi(local.systemImage) === androidSystemImageAbi(choice.systemImage);
+			},
+			...remoteEasFallbackSetting(settings) ? { eas: () => checkEasFallback({
+				root,
+				platform: "android",
+				slot,
+				release: build.release,
+				isExpo,
+				tunnelMode: tunnelModeSetting(settings),
+				publicUrl: publicUrlSetting(settings),
+				localOnlyFlags: typeof opts.systemImage === "string" ? ["--system-image"] : []
+			}) } : {}
+		});
+		if (hostedPlan.kind === "unknown") return refuse({
+			code: "STIM_BAD_ARG",
+			message: `android.remote is ${target.machine}, and its emulator ABI is unknown here: ${hostedPlan.reason}.`,
+			remedy: "Run `stim android` to build for the remote device, or unset android.remote to plan the owned emulator."
+		});
+		placement = hostedPlan.placement;
+		if (hostedPlan.kind === "hosted" && "architecture" in hostedPlan.choice) hostedAbi = hostedPlan.choice.architecture ?? null;
+		image = hostedPlan.kind === "hosted" ? { systemImage: abiKeyed && "systemImage" in hostedPlan.choice ? hostedPlan.choice.systemImage : null } : localImage();
+	} else image = localImage();
+	if ("refusal" in image) return refuse(image.refusal);
+	const { abi, runOptions, remoteRunOptions } = androidBuildOptions({
+		release: build.release,
+		physical: false,
+		device: { systemImage: image.systemImage },
+		variant: build.variant,
+		deviceAbi: () => null,
+		gradleProject: androidGradleProject(layout),
+		buildProfile: build.profile,
+		targetAbiOnly: build.targetAbiOnly,
+		hostedAbi
+	});
+	let fingerprint;
+	try {
+		fingerprint = await deps.fingerprint(root, {
+			platform: PLATFORM,
+			androidLayout: layout
+		});
+	} catch (error) {
+		return refuse({
+			code: NO_FINGERPRINT,
+			message: `@expo/fingerprint could not fingerprint ${root}: ${error?.message || error}`,
+			remedy: "Fix the @expo/fingerprint error above, then retry."
+		});
+	}
+	if (!fingerprint?.hash) return refuse({
+		code: NO_FINGERPRINT,
+		message: `@expo/fingerprint returned no hash for ${root}, so the build cache cannot be addressed.`,
+		remedy: "Check the project native inputs and the @expo/fingerprint error above, then retry."
+	});
+	const plan = await planCachedBuild({
+		...planTarget,
+		isExpo,
+		fingerprint: fingerprint.hash,
+		sources: fingerprint.sources ?? [],
+		cacheKey: buildCacheKey(PLATFORM, fingerprint.hash, runOptions),
+		cachePolicy: build.cache,
+		providerConfig: cacheProviderConfig,
+		expoRemote: abi || build.profile || !build.cache.remote ? null : { runOptions: remoteRunOptions }
+	}, {
+		...deps,
+		note
+	});
+	return placement ? {
+		...plan,
+		placement
+	} : plan;
+}
+//#endregion
+//#region src/integrations/react-native-android.ts
+const runtimeKind = ({ release }) => release ? "embedded-js" : "metro";
+function reactNativeAndroidProject(root, { context, settings }, dependencies = {}) {
+	const isExpo = detectIsExpo(root);
+	const layout = resolveAndroidLayout(settings, root, context.repoRoot ?? root);
+	const variantProblem = (variant) => productFlavorRefusal({
+		flavors: readProductFlavors(layout),
+		variant
+	});
+	return {
+		plan: (options, resolved) => planReactNativeAndroid(root, options, runtimeKind, resolved, layout, variantProblem, dependencies.plan),
+		isExpo,
+		appIds: () => detectAppIds(root, void 0, layout.moduleDir),
+		packageRemedy: `Set \`expo.android.package\` in app.json / app.config.js, or \`namespace\` in ${relative(root, layout.moduleDir) || "."}/build.gradle.`,
+		variantProblem,
+		targets: [
+			"emulator",
+			"physical",
+			"hosted",
+			"remote"
+		],
+		eas: true,
+		runtimeKind,
+		runtime: ({ build, prepareMetro, phase }) => runtimeKind(build) === "embedded-js" ? androidProcessRuntime(async () => {
+			phase("metro", `skipped (${build.variant}: the JS bundle is embedded, no dev server is used)`);
+			return {
+				ok: true,
+				prepared: { metroPort: null }
+			};
+		}, "embedded-js") : androidMetroRuntime(prepareMetro),
+		artifact: (artifactContext) => reactNativeAndroidArtifact(artifactContext, isExpo, layout, context, dependencies)
+	};
+}
+function reactNativeAndroidArtifact({ root, buildLog, writer, settings, buildPlan, target, phase, out, step, estimates }, isExpo, layout, context, { fingerprint = fingerprintProject, untracked = untrackedNativeFiles, resolveCached = resolveBuild, storeCached = storeBuild, storedAssets = storedAssetManifest, captureAssets = captureAssetManifest, loadProvider = loadProjectProvider, planPrebuildFor = planPrebuild, prebuild = runPrebuild, build = buildAndroid, ccacheFor = resolveCcache, swapApk = swapApkBundle, readState = readWorkspaceState }) {
+	const { variant, release, profile, cas } = buildPlan;
+	const runOptions = {
+		...variant ? { variant } : {},
+		...target.abi ? { abi: target.abi } : {},
+		...cas?.id ? { compiler: cas.id } : {},
+		...profile ? { buildProfile: profile } : {},
+		...androidGradleProject(layout) ? { gradleProject: androidGradleProject(layout) } : {}
+	};
+	let hash = "";
+	let sources = [];
+	let initialSources = [];
+	let prebuildRan = false;
+	let editedConfig = [];
+	const identity = () => ({
+		hash,
+		key: buildCacheKey("android", hash, runOptions)
+	});
+	const materialize = async (key, cachedPath) => {
+		if (!release) return {
+			apkPath: cachedPath,
+			directory: null
+		};
+		phase("swap", `regenerating this workspace's JS for the cached ${variant} APK`);
+		let keystore;
+		try {
+			keystore = resolveKeystore(root, settings, layout, settingOriginScope(settingsLayers(context), "android.keystore") === "committed" ? context.repoRoot ?? root : null);
+		} catch (error) {
+			phase("swap", chalk.yellow(`${error.message} -- building fresh instead`));
+			return null;
+		}
+		const swap = await swapApk({
+			root,
+			isExpo,
+			cachedApkPath: cachedPath,
+			keystore,
+			layout,
+			logWriter: writer,
+			storedAssets: storedAssets("android", key)
+		});
+		if (swap?.ok && swap.apkPath) {
+			if (swap.note) phase("swap", chalk.yellow(swap.note));
+			phase("swap", `${swap.hermes ? "hermes bytecode" : "plain JS"} repacked (store), zipaligned and re-signed (${formatDuration(swap.durationMs)})`);
+			return {
+				apkPath: swap.apkPath,
+				directory: swap.tmpDir ?? null
+			};
+		}
+		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));
+		return null;
+	};
+	return {
+		async identity() {
+			let computed;
+			try {
+				computed = await fingerprint(root, {
+					platform: "android",
+					androidLayout: layout
+				});
+			} catch (error) {
+				const message = String(error?.message || error);
+				throw new AndroidRecipeRefusal({
+					code: NO_FINGERPRINT,
+					message: `@expo/fingerprint could not fingerprint ${root}: ${message}`,
+					remedy: "Fix the @expo/fingerprint error above, then retry.",
+					extra: { lastBuildStatus: true }
+				}, fingerprintErrorMissReason(message));
+			}
+			if (!computed?.hash) throw new AndroidRecipeRefusal({
+				code: NO_FINGERPRINT,
+				message: `@expo/fingerprint returned no hash for ${root}, so the build cache cannot be addressed.`,
+				remedy: "Check the project native inputs and the @expo/fingerprint error above, then retry.",
+				extra: { lastBuildStatus: true }
+			}, fingerprintErrorMissReason("no hash"));
+			hash = computed.hash;
+			sources = initialSources = computed.sources ?? [];
+			return identity();
+		},
+		cache: (compiled = false) => filesystemBuildCapability({
+			resolve: resolveCached,
+			store: storeCached,
+			sources,
+			...compiled ? { assetManifest: release ? captureAssets(root, {
+				variant,
+				layout
+			}) : null } : {}
+		}),
+		async prepare(beforePrepare) {
+			const plan = planPrebuildFor(root, "android", {
+				isExpo,
+				fingerprint: hash,
+				sources
+			});
+			prebuildRan = plan === "generate" || plan === "regenerate";
+			if (plan === "refuse") {
+				const refusal = staleNativeDirRefusal("android");
+				throw new AndroidRecipeRefusal({
+					...refusal,
+					extra: { lastBuildStatus: true }
+				});
+			}
+			if (!prebuildRan) return;
+			beforePrepare();
+			step("prebuild");
+			recordPrebuild(root, "android", null);
+			const pre = await prebuild(root, "android", writer, {
+				isExpo,
+				clean: plan === "regenerate"
+			});
+			if (pre.failed) throw new AndroidRecipeRefusal({
+				code: pre.code,
+				message: pre.reason,
+				remedy: pre.remedy,
+				extra: {
+					lastBuildStatus: true,
+					lines: (pre.lastLines ?? []).slice(-5),
+					logPath: displayPath(root, buildLog)
+				}
+			});
+			phase("prebuild", `${plan === "generate" ? "android/ generated" : "android/ not generated from this fingerprint -> regenerated with --clean"} (${formatDuration(pre.durationMs)})`);
+		},
+		async reconcile() {
+			const rekeyedBy = [];
+			if (prebuildRan) {
+				const after = await refingerprintAfterMutation({
+					projectRoot: root,
+					platform: "android",
+					androidLayout: layout,
+					previousHash: hash,
+					fingerprint
+				});
+				editedConfig = after ? configInputsChanged(initialSources, after.sources, { prebuildRan }) : [];
+				if (after && !editedConfig.length) recordPrebuild(root, "android", after.hash);
+				if (after?.moved && !editedConfig.length) {
+					rekeyedBy.push("prebuild");
+					phase("fingerprint", chalk.dim(`${shortHash(hash)} -> ${shortHash(after.hash)} (after prebuild)`));
+					hash = after.hash;
+					sources = after.sources;
+				}
+			}
+			return {
+				identity: identity(),
+				rekeyedBy,
+				cacheRefusal: editedConfig.length ? "prebuild changed config inputs, so the APK cannot be cached" : null,
+				...prebuildRan ? { androidPackage: detectAndroidPackage(root, layout.moduleDir) } : {}
+			};
+		},
+		async validate() {
+			const after = editedConfig.length ? null : await refingerprintAfterMutation({
+				projectRoot: root,
+				platform: "android",
+				androidLayout: layout,
+				previousHash: hash,
+				fingerprint
+			});
+			const changed = after ? inputsChangedDuringBuild({
+				platform: "android",
+				lookup: initialSources,
+				prebuildRan,
+				compiled: sources,
+				current: after.sources
+			}) : editedConfig;
+			if (!after || changed.length) {
+				phase("fingerprint", chalk.yellow(changed.length ? changedDuringBuildLine(changed) : "unavailable after Gradle; the build will be installed but not cached"));
+				return null;
+			}
+			if (after.moved) {
+				phase("fingerprint", chalk.dim(`${shortHash(hash)} -> ${shortHash(after.hash)} (after Gradle)`));
+				hash = after.hash;
+				sources = after.sources;
+			}
+			return identity();
+		},
+		materialize,
+		compile: () => build({
+			root,
+			layout,
+			logWriter: writer,
+			variant,
+			abi: target.abi
+		}, {
+			estimateMs: estimates().coldBuildMs,
+			ccache: buildPlan.compilerCache === "ccache" ? ccacheFor({
+				root,
+				layout,
+				onNote: out
+			}) : null,
+			cas,
+			buildCache: buildPlan.gradleBuildCache,
+			pch: buildPlan.pch,
+			compilerCacheDisabled: buildPlan.compilerCache === "none"
+		}),
+		explain(rekeyedBy) {
+			const explained = explainBuildMiss({
+				root,
+				platform: "android",
+				current: {
+					hash,
+					sources
+				},
+				rekeyedBy,
+				baselineDeps: { readState }
+			});
+			return {
+				reason: explained.reason,
+				diff: explained.previousHash && explained.changedNames.length ? fingerprintDiffRecord({
+					changed: explained.changedNames,
+					previousHash: explained.previousHash,
+					hash
+				}) : null
+			};
+		},
+		untrackedLine: () => untrackedMissLine(untracked({ projectRoot: root })),
+		legacyCache: target.abi || cas || profile || !buildPlan.cache.remote ? null : {
+			load: () => loadProvider(root, { isExpo }),
+			runOptions: Object.keys(runOptions).length ? runOptions : null
+		},
+		offload: {
+			unsupported: release ? `${variant} builds build here` : cas ? "Apple Clang CAS builds build here" : !buildPlan.cache.write ? "the build cache is off" : null,
+			target: () => ({
+				platform: "android",
+				local: androidToolchain(),
+				requires: androidRequirements(root)
+			}),
+			request: {
+				platform: "android",
+				isExpo,
+				android: {
+					variant,
+					abi: target.abi,
+					gradleBuildCache: buildPlan.gradleBuildCache,
+					pch: buildPlan.pch,
+					compilerCache: buildPlan.compilerCache === "none" ? "none" : "ccache",
+					...androidJobLayout(layout)
+				}
+			},
+			unchanged: async () => {
+				const after = await refingerprintAfterMutation({
+					projectRoot: root,
+					platform: "android",
+					androidLayout: layout,
+					previousHash: hash,
+					fingerprint
+				});
+				return Boolean(after && !after.moved);
+			}
+		}
+	};
+}
+//#endregion
+export { reactNativeAndroidProject };