stim 1.19.0 → 1.20.0

package/dist/android-BXc6BmEi.mjs

@@ -1,3732 +0,0 @@
-import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { _ as stepTimer, c as launchErrorReport, f as refuseNoProject, g as stepClock, i as formatDuration, l as phaseLine, m as shortHash, n as appReadinessMessage, v as launchErrorPreview } from "./command-output-Bt8ygHE7.mjs";
-import { C as saveConfig, D as withConfigLock$1, E as upsertProject, L as deviceSlotFileKey, R as deviceSlotKey, V as parseDeviceSlotOption, W as validateDeviceSlot, _ as loadConfig$1, j as formatBytes, p as getProject, u as getConcurrencyLimits, w as setDevice, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
-import { c as writeWorkspaceState, g as workspaceAgentDeviceDir, i as recordWorkspaceUse, l as emulatorLogFile, r as readWorkspaceState$1, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-CR9X86xJ.mjs";
-import { M as writeWorkspaceLaunch, b as MODE_EXPO, c as projectShortcut, p as detectIsExpo, r as findProjectRoot, s as projectProblem, t as NO_PROJECT_REFUSAL, y as MODE_BARE } from "./project-B5eQ1USs.mjs";
-import { A as publicUrlSetting, B as settingShapeErrors, C as metroWarmupUrlSetting, Ct as removeTemporaryEntry, Dt as optimizationBuildProfile, Et as compilerCacheFallbackMessage, F as resolveCacheProviderConfig, H as settingsLayers, I as resolveSettings, L as settingFile, M as remoteAndroidSetting, N as remoteEasFallbackSetting, Ot as resolveOptimizations, St as makeTemporaryDirectory, T as parseIosRemote, Tt as artifactCachePolicy, U as tunnelModeSetting, W as unknownSettingKeys, i as SETTING_SHAPE_REMEDY, l as androidDataPartitionSizeGbSettingError, mt as repoRoot, nt as gitCommonDir, o as androidAvdConfigSettingError, q as detectProviders, u as cacheProviderSettingError, x as metroPortSetting, z as settingOriginScope } from "./settings-CxgngUZk.mjs";
-import { d as signalProcessTree, s as pidExists, u as resolveProjectMetro } from "./metro-DI2AjPF_.mjs";
-import { F as recordFinishedBuild, I as startBuildProgress, L as tapBuildLog, O as NO_BUILD_PROGRESS, R as createRunRecorder, U as recordRunStats, V as recordCapacityRefusal, W as statsProjectKey$1, t as budgetGate, z as readRunEstimates } from "./budget-Dz-kyXLv.mjs";
-import { D as teardownOwnedAvd, M as acquireBuildSlot, P as releaseBuildSlot } from "./workspaces-Djb2gfi9.mjs";
-import { A as providerDownloadPath, 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, _ as waitForBuild, b as buildCacheKey, g as releaseBuildLock, j as providerUploadOutcome, k as prepareProviderDownloadDir, m as acquireBuildLock, v as waitForSharedBuild, x as changedDuringBuildLine, z as assetDiffReason } from "./device-lease-Cu7PtQpZ.mjs";
-import { $ as trimAndroidCaches, A as listAvds, B as ownedAvdSystemImage, D as hostSystemImageArch, F as ownedAvdDeviceProfile, G as probeEmulatorSerial, I as ownedAvdDirectory, J as resolveOwnedAvdSerial, K as profileNeedsFoldFeature, O as listAdbDevices, Q as systemImageSupportsFold, T as findBuildTool, U as physicalDeviceModel, W as pickDefaultSystemImage, Y as resolvePhysicalDevice, a as androidDeviceAbi, ft as parkedMaxSetting, i as androidDataFreeBytes, j as listInstalledSystemImages, k as listAvdDeviceProfiles, l as androidSystemImageAbi, q as resetAdoptedAvd, r as androidBuildToolName, rt as configuredAndroidEmulatorApp, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, u as androidToolCwd } from "./android-BdQC6zs1.mjs";
-import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-C65jk_q2.mjs";
-import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
-import { A as resolveBuildPlacement, C as setRemoteLogSink, D as parseBuildMachineOption, E as namedBuildMachine, O as requireLocalBuild, S as withNativeBuildRun, a as offloadBuild, b as runCancellation, c as placementLoad, i as closeOffload, l as remotePhaseText, n as buildPlacementCandidates, p as cancelledFailure, r as chooseBuildMachine, s as offloadPlacement, w as OffloadRefusal, x as runCancellationSignal } from "./client-CuUo8Nvg.mjs";
-import { n as DeviceAdmissionRefusal, r as checkDeviceCapacity, t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-BoN1jQkO.mjs";
-import { i as ccacheActivityLine, n as CCACHE_NOT_RUN, r as CCACHE_UNAVAILABLE, s as resolveCcache } from "./manifest-CX0d1IkZ.mjs";
-import { E as startBuildHeartbeat, O as tailLines, h as HEARTBEAT_INTERVAL_MS, n as androidToolchain, t as androidRequirements } from "./toolchain-C3xSoyUl.mjs";
-import { t as cleanLine } from "./server-expo-n3tUi3Em.mjs";
-import { r as hostedMetroSettings } from "./metro-gateway-BxpJLIwh.mjs";
-import { a as writeHostedAndroid, i as writeDevicePlacement, t as readHostedAndroid } from "./ios-state-By0XuLTQ.mjs";
-import { _ as devicePlacementLine, a as UPDATES_MANIFEST_NAME, d as ensureOwnedDevice, f as AvdBootError, g as automaticDevicePlacement, h as checkEasFallback, i as skippedMissReason, l as didSetUpDevice, m as warmMetro, n as fingerprintErrorMissReason, o as detectEntryFile, p as AvdRecoveryError, s as refreshUpdatesManifestFile, t as explainBuildMiss, u as ensureBooted } from "./miss-reason-CjQCOKqq.mjs";
-import { n as devicePlacementRecord, t as buildPlacementRecord } from "./placement-log-Dxe34rJm.mjs";
-import { n as prepareHostedAndroid, t as placeHostedAndroid } from "./hosted-android-Bs7fytj7.mjs";
-import { S as restartedAppNote, b as launchAndroidReleaseApp, c as androidDevClientUrl, g as installConflictKind, h as installAndroidApp, r as DEFAULT_METRO_PORT, s as androidAppProcess, t as ADB_INSTALL_TIMEOUT_MS, y as launchAndroidApp } from "./app-install-CFI4ptUL.mjs";
-import { n as nativeRunCommand, r as siblingPlatformSlots, t as launchSlotScope } from "./slot-launch-HV_KtPIw.mjs";
-import { a as VERIFY_TIMEOUT_MS, d as verifyAndroidReleaseLaunch, f as verifyLaunch, i as RELEASE_VERIFY_WAIT_MS, l as unattributedLaunchLines, n as LAUNCH_FATAL, r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING, u as unverifiedLaunchLines } from "./launch-verify-DCveSE6d.mjs";
-import { a as easAuthNote, c as loadProjectProvider, f as resolveEasCliBin, i as checkEasAuth, m as uploadRemote, n as UPLOAD_TIMEOUT_MS, o as exitAfterFlush, p as resolveRemote, r as cacheLevel, s as isEasAuthFailureText, t as RESOLVE_TIMEOUT_MS } from "./remote-cache-N3hAEaAL.mjs";
-import { C as resolveSystemImage, S as resolveDeviceProfile, T as systemImageRefusal, _ as isReleaseVariant, a as PLATFORM, b as pooledAndroidDevice, d as apkPackage, f as deviceProfileRefusal, g as foldableImageRefusal, i as NO_FINGERPRINT, m as dumpApkManifest, n as LAUNCH_FAILED, o as androidBuildOptions, p as displayPath, r as NO_DEVICE, s as androidDevClientScheme, t as INSTALL_FAILED, v as noDeviceDiagnostic, w as resolveVariant, x as remoteAvdFlagRefusal } from "./support-DsNaFg6D.mjs";
-import { d as productFlavorRefusal, f as readProductFlavors, h as formatDiagnostic, o as buildAndroid } from "./device-ios-B2ruohE-.mjs";
-import { T as ownedSessionName, a as ensureMetroReachable, c as remoteAndroidDeps, n as binOnPath, o as ensureRemoteBootOwned, u as resolveRemoteContext } from "./device-remote-B5GiUifk.mjs";
-import { a as isEasBuildFailure, o as planEasDevelopmentBuild, s as resolveEasDevelopmentBuild } from "./simslim-D9LkJxIO.mjs";
-import { c as startDevServer, m as detectAppIds, p as detectAndroidPackage } from "./start-DtxthMfI.mjs";
-import { a as acquireRunLease, c as lostRefusal, d as runLease, f as waitFlagConflict, l as parseDeviceWait, o as leaseExpiryText, s as lostLine, t as DEBUG_VERIFY_STEP_MS, u as releaseLeaseOnSignal } from "./device-lease-run-D38SnZtt.mjs";
-import { n as verifyCollectorOwnership, r as readCollectors } from "./ownership-EB0ySdGK.mjs";
-import { i as launchOutcomeRecord, n as ensureWorkspaceStorageSafely, r as isPhysicalDeviceRequest, t as ensureDevServer } from "./native-runtime-BGxsbfny.mjs";
-import { t as selectFromPool } from "./device-pool-CP4rAsHx.mjs";
-import { i as staleNativeDirRefusal, n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-BKJ3wJI1.mjs";
-import { a as printPlan, i as planPayload, n as planCachedBuild, o as refusePlan, r as planFlagRefusal, s as runArtifactLifecycle, t as planHostedDevice } from "./plan-placement-BVY59qa8.mjs";
-import { a as printNativeCrashReport, r as captureNativeCrashes, t as errorDiagnostics } from "./error-diagnostics--v5HGOU0.mjs";
-import { n as resolveAndroidCas, r as resolveAndroidCompilerCache } from "./android-cas-C87geAg-.mjs";
-import { constants, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync } from "node:fs";
-import { basename, dirname, isAbsolute, join } from "node:path";
-import { buildDiagnostics, hostedAndroidStatus, machineCapacity, parseMachine } from "@stim-cli/core/state";
-import chalk from "chalk";
-import { InvalidArgumentError } from "commander";
-import { workspaceId } from "@stim-cli/core";
-import { createWarnOnce, loadCacheProvider, resolveTieredBuild, storeTieredBuild } from "@stim-cli/cache";
-//#region src/commands/android/remote.ts
-async function connectAndroidHosting({ root, slot, machine, release, metroCheck, selectors, read = readHostedAndroid, resolveSerial = resolveOwnedAvdSerial, prepare = prepareHostedAndroid }) {
-	let recorded;
-	try {
-		recorded = read(root, slot)[slot];
-	} catch (error) {
-		return { failure: {
-			code: "STIM_HOSTING_REFUSED",
-			message: error.message,
-			remedy: `Restore that slot's recorded machine and session from the host, then run stim stop${slot === "default" ? "" : ` --slot ${slot}`} to reconcile it.`
-		} };
-	}
-	if (recorded && recorded.machine !== machine) return { failure: {
-		code: "STIM_BAD_ARG",
-		message: `This workspace's Android emulator runs on ${recorded.machine}; run stim stop first.`
-	} };
-	if (!machine) return { target: null };
-	if (!release && !metroCheck) return { failure: {
-		code: "STIM_BAD_ARG",
-		message: "Hosted Debug runs require the local Metro supervisor; --no-metro-check cannot be used.",
-		remedy: "Run stim stop; stim start, then retry without --no-metro-check."
-	} };
-	const local = deviceSlotPlatforms(getProject(root), slot)?.android;
-	if (local?.owned && local.avdName) {
-		let running = true;
-		try {
-			const resolved = resolveSerial(local.avdName, { timeoutMs: 5e3 });
-			running = Boolean(resolved.serial) || !resolved.notRunning && !resolved.missing;
-		} catch {}
-		if (running) return { failure: {
-			code: "STIM_BAD_ARG",
-			message: `This workspace's Android emulator for slot ${slot} runs on this Mac; run stim stop first.`
-		} };
-	}
-	try {
-		return { target: await prepare(machine, selectors, recorded) };
-	} catch (error) {
-		return { failure: {
-			code: error.code ?? "STIM_HOSTING_REFUSED",
-			message: error.message,
-			...error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? { remedy: error.remedy } : {}
-		} };
-	}
-}
-async function selectAndroidPlacement({ target: selected, automatic = automaticDevicePlacement, checkBudget = budgetGate, note, phase, log, fromFlag, noWait, buildMachine, localSelectors, eas, ...args }) {
-	const selectors = selected.kind === "hosted" ? {
-		...selected.systemImage ? { systemImage: selected.systemImage } : {},
-		...selected.deviceProfile ? { deviceProfile: selected.deviceProfile } : {}
-	} : {};
-	if (selected.kind !== "hosted" || selected.machine !== "auto") {
-		const connected = await connectAndroidHosting({
-			...args,
-			selectors,
-			machine: selected.kind === "hosted" ? selected.machine : null
-		});
-		if ("failure" in connected) return connected;
-		return {
-			target: selected,
-			hostedTarget: connected.target,
-			selectors,
-			budget: connected.target ? {
-				reclaimed: [],
-				refusal: null
-			} : await checkBudget({
-				root: args.root,
-				note
-			})
-		};
-	}
-	const refusal = localSelectors(selected);
-	if (refusal) return { failure: refusal };
-	try {
-		const placed = await automatic({
-			root: args.root,
-			slot: args.slot,
-			platform: "android",
-			selectors,
-			buildMachine,
-			noWait,
-			...eas ? { eas } : {}
-		});
-		phase("placement:", devicePlacementLine(placed.placement, placed.skipped));
-		log?.(devicePlacementRecord({
-			platform: "android",
-			fromFlag,
-			easFallback: Boolean(eas),
-			placed
-		}));
-		if (placed.placement.decision === "eas") return {
-			target: {
-				kind: "remote",
-				backend: "eas",
-				systemImage: selected.systemImage,
-				deviceProfile: selected.deviceProfile
-			},
-			hostedTarget: null,
-			selectors,
-			budget: await checkBudget({
-				root: args.root,
-				note
-			}),
-			devicePlacement: placed.placement
-		};
-		if (placed.target && !args.release && !args.metroCheck) return { failure: {
-			code: "STIM_BAD_ARG",
-			message: "Hosted Debug runs require the local Metro supervisor; --no-metro-check cannot be used.",
-			remedy: "Run stim stop; stim start, then retry without --no-metro-check."
-		} };
-		return {
-			target: placed.target ? {
-				...selected,
-				machine: placed.target.host.machine
-			} : {
-				kind: "emulator",
-				systemImage: selected.systemImage,
-				deviceProfile: selected.deviceProfile
-			},
-			hostedTarget: placed.target,
-			selectors,
-			budget: placed.target ? {
-				reclaimed: [],
-				refusal: null
-			} : await checkBudget({
-				root: args.root,
-				note
-			}),
-			devicePlacement: placed.placement
-		};
-	} catch (error) {
-		return { failure: {
-			code: error.code ?? "STIM_HOSTING_REFUSED",
-			message: error.message,
-			...error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? { remedy: error.remedy } : {}
-		} };
-	}
-}
-//#endregion
-//#region src/commands/android/result.ts
-function androidFacts({ root, slot, serial, avdName = null, deviceName = null, systemImage = null, deviceProfile = 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, devServer = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null, host }) {
-	return {
-		platform: PLATFORM,
-		...host ? { host } : {},
-		...slot && slot !== "default" ? { slot } : {},
-		serial: serial ?? null,
-		avdName: avdName ?? null,
-		deviceName: deviceName ?? avdName ?? null,
-		systemImage: systemImage ?? null,
-		deviceProfile: deviceProfile ?? null,
-		fingerprint: fingerprint ?? null,
-		cacheKey: cacheKey ?? null,
-		variant: variant ?? null,
-		metroPort: metroPort ?? null,
-		cacheHit: cacheLevel(cacheHit),
-		cacheSkipped: Boolean(cacheSkipped),
-		buildMachine,
-		...builtOn ? { builtOn } : {},
-		...offloadedTo ? { offloadedTo } : {},
-		...offloadFallback ? { offloadFallback } : {},
-		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,
-		...root && !host ? { agentDevice: { stateDir: workspaceAgentDeviceDir(root) } } : {},
-		durationMs: typeof durationMs === "number" && Number.isFinite(durationMs) ? durationMs : null,
-		...lease === void 0 ? {} : { lease },
-		...devServer ? { devServer } : {}
-	};
-}
-function lastBuildRecord({ devicePlacement, fingerprint, cacheKey, cacheHit, cacheSkipped = false, durationMs, appPath, bundleId, startedAt, status, errorCode = null, avdName = null, deviceName = null, missReason = null, diagnostics = null, configuration = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = 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,
-		configuration: configuration ?? null
-	};
-	if (errorCode) record.errorCode = errorCode;
-	if (devicePlacement) record.devicePlacement = devicePlacement;
-	record.buildMachine = buildMachine;
-	if (builtOn) record.builtOn = builtOn;
-	if (offloadedTo) record.offloadedTo = offloadedTo;
-	if (offloadFallback) record.offloadFallback = offloadFallback;
-	if (missReason && !cacheLevel(cacheHit)) record.missReason = missReason;
-	const recorded = status === "failed" ? buildDiagnostics(diagnostics) : [];
-	if (recorded.length) record.diagnostics = recorded;
-	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({ host, root, slot, json, useBuildCache, variant, release, metroCheck, metroPort, logsDir, serial, apkPath, androidPackage, installSkipped, record, waitedForBuild, remote, providerName, launchState, launchWarning, launched, ccache, durationMs, writer, emit, lease, recordRun, reclaimed = [], devServer = null, links }) {
-	const offloadedTo = record.offloadedTo ?? null;
-	recordRun({
-		failed: false,
-		cacheHit: cacheLevel(record.cacheHit),
-		waited: waitedForBuild,
-		durationMs,
-		offloadedTo
-	});
-	const facts = androidFacts({
-		host,
-		root,
-		slot,
-		serial,
-		avdName: record.avdName,
-		deviceName: record.deviceName,
-		systemImage: record.systemImage,
-		deviceProfile: record.deviceProfile,
-		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,
-		devServer,
-		buildMachine: record.buildMachine,
-		builtOn: record.builtOn ?? void 0,
-		offloadedTo,
-		offloadFallback: record.offloadFallback ?? null
-	});
-	writer.close();
-	if (record.devicePlacement) facts.devicePlacement = record.devicePlacement;
-	if (json) emit(JSON.stringify({
-		...facts,
-		...links ? { links } : {},
-		...reclaimed.length ? { reclaimed } : {}
-	}));
-	else {
-		const summary = `${launchWarning ? "WARNING" : "OK"}: ${androidPackage} launched on ${host ? `${host.device?.name ?? "Android emulator"} on ${host.machine}` : serial}, ${release ? `${variant} (embedded JS, no Metro)` : `Metro port ${metroPort}`} (${cacheOutcome(record.cacheHit, remote?.name ?? providerName, offloadedTo)})`;
-		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, offloadedTo) : `bypassed; ${cacheOutcome(false, null, offloadedTo)}`;
-		const metroResult = release ? `embedded (${variant})` : !metroCheck ? `check skipped on port ${metroPort}` : launchState === "unverified" ? `state unverified on port ${metroPort}` : `running on port ${metroPort}${devServer ? ` (started: ${devServer.reason})` : ""}`;
-		emit([
-			outcome,
-			phaseLine("device", host ? `${deviceName} on ${host.machine}` : `${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)"),
-			...!host ? [phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`)] : []
-		].join("\n"));
-		if (links) console.error(chalk.dim(workspaceLinkLine(links)));
-	}
-	return facts;
-}
-function cacheOutcome(cacheHit, providerName = null, offloadedTo = null) {
-	if (cacheHit === "remote") return `cache hit from ${providerName || "the remote cache"}`;
-	if (cacheHit === "local") return "cache hit";
-	return offloadedTo ? `built on ${offloadedTo}` : "built";
-}
-function persistLastBuild({ recordBuild = recordFinishedBuild, root, record, startedAt, durationMs, status, errorCode = null, diagnostics = null, out }) {
-	const lastBuild = lastBuildRecord({
-		...record,
-		startedAt,
-		durationMs,
-		status,
-		errorCode,
-		diagnostics
-	});
-	try {
-		recordBuild(root, lastBuild);
-	} catch (err) {
-		out(phaseLine("state", chalk.yellow(`could not record lastBuild: ${err?.message || err}`)));
-	}
-	return lastBuild;
-}
-//#endregion
-//#region src/commands/android/hosted.ts
-async function finishHostedAndroidRun({ target, artifact, root, slot = "default", release, isExpo, metroPort, logsDir, selectors, place, writePlacement, verifyLaunch: verify, writeLaunch, readApkPackage, resolveDevClientScheme, now, started, startedAt, fail, phase, enterPhase, out, recordBuild, ...report }) {
-	const packageName = artifact.androidPackage ?? readApkPackage(artifact.apkPath);
-	if (!artifact.apkPath || !packageName) return fail("STIM_INSTALL_FAILED", "The built APK has no package identity.");
-	const launchedAt = now();
-	try {
-		const run = await place(target, {
-			root,
-			slot,
-			bundle: artifact.apkPath,
-			handoff: artifact.handoff,
-			bundleId: packageName,
-			release,
-			metroPort,
-			selectors,
-			...!release && isExpo ? { devClientScheme: resolveDevClientScheme(root, artifact.apkPath) ?? void 0 } : {},
-			reserved: (placement) => writePlacement(root, slot, placement),
-			note: out,
-			enterPhase
-		});
-		writePlacement(root, slot, run.placement);
-		writeLaunch(root, "android", {
-			appId: packageName,
-			deviceId: run.placement.session,
-			metroPort,
-			release,
-			launchedAt: new Date(launchedAt).toISOString()
-		});
-		let launched = run.launched;
-		if (!release) {
-			const evidence = await verify({
-				requireBundleResponse: true,
-				platform: "android",
-				logsDir: logsDir ?? void 0,
-				since: launchedAt,
-				metroPort,
-				mode: isExpo ? MODE_EXPO : MODE_BARE,
-				slot: launchSlotScope(root, slot),
-				platformShared: siblingPlatformSlots(root, "android", slot).length > 0
-			});
-			if (evidence.fatal) return fail("STIM_LAUNCH_FAILED", "Metro could not deliver the hosted app bundle.", "Run stim logs --errors and fix the bundle error.");
-			launched = evidence.verified ? true : evidence.requested ? "bundling" : "unverified";
-		}
-		if (launched === "unverified") out(`Launch on ${target.host.machine} is unverified; check the hosted app, then retry stim android --remote ${target.host.machine}.`);
-		const host = hostedAndroidStatus(run.placement);
-		report.record.deviceName = host.device?.name ?? null;
-		report.record.bundleId = packageName;
-		persistLastBuild({
-			recordBuild,
-			root,
-			record: report.record,
-			startedAt,
-			durationMs: now() - started,
-			status: "success",
-			out
-		});
-		await finishAndroidUpload(artifact.uploadPending, artifact.remote, phase);
-		await artifact.providerUpload;
-		return {
-			ok: true,
-			facts: reportAndroidResult({
-				...report,
-				root,
-				slot,
-				release,
-				metroPort,
-				logsDir,
-				host,
-				serial: null,
-				apkPath: artifact.apkPath,
-				androidPackage: packageName,
-				installSkipped: false,
-				waitedForBuild: artifact.waitedForBuild,
-				remote: artifact.remote,
-				providerName: artifact.providerName,
-				launchState: launched,
-				launched: {},
-				ccache: artifact.ccache,
-				durationMs: now() - started
-			})
-		};
-	} catch (error) {
-		return fail(error.code ?? "STIM_HOSTING_REFUSED", error.message, `Retry stim android --remote ${target.host.machine}, or run stim stop to reconcile the recorded placement.`);
-	} finally {
-		if (artifact.swapDir) rmSync(artifact.swapDir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-//#endregion
-//#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) {
-	try {
-		return hermesEnabledFromGradleProperties(readFileSync(join(root, "android", "gradle.properties"), "utf-8"));
-	} catch {
-		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
-	];
-}
-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() !== "" ? isAbsolute(configured.trim()) ? 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), 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)) {
-		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
-		}));
-	} 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/commands/android/artifact.ts
-const FALLBACK_LINES = 5;
-function fail$1(code, message, remedy, extra = {}) {
-	return {
-		code,
-		message,
-		remedy,
-		extra
-	};
-}
-var ArtifactRefusal = class extends Error {
-	failure;
-	constructor(failure) {
-		super(failure.message ?? failure.code);
-		this.failure = failure;
-	}
-};
-async function acquireAndroidArtifact({ root, buildLog, writer, settings, isExpo, device, physical, hostedAbi, remote: remoteTarget, buildPlan, cacheProviderConfig, requestedBuildCache, easBuild, androidPackage: initialPackage, record, maxBuilds, progress }, { deviceAbi, fingerprint, untracked, resolveCached, storeCached, storedAssets, captureAssets, acquireLock, releaseLock, waitForBuild, loadProvider, easAuth, resolveRemoteBuild, uploadRemoteBuild, loadCacheProviderModule, acquireSlot, releaseSlot, planPrebuildFor, prebuild, build, ccacheFor, swapApk, readState, now }) {
-	const { phase, out, estimates, stats, step, miss, hit: lateHit, place, waitingOn, waitingFor } = progress;
-	let fallbackMachine = null;
-	let hereReason = "no remote Mac is paired";
-	let slotWaitMs;
-	const buildMachine = record.buildMachine ?? "auto";
-	const fallBack = (reason, line = reason, info = {}) => {
-		writer.write(buildPlacementRecord({
-			platform: PLATFORM,
-			buildMachine,
-			candidates: info.candidates,
-			event: "placement_fallback",
-			fallback: {
-				code: info.code ?? "fallback",
-				reason,
-				machine: info.machine
-			}
-		}));
-		if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, reason);
-		requireLocalBuild(buildMachine);
-		record.offloadFallback = reason;
-		phase("build", `${line} -> building here`);
-	};
-	const { variant, release, profile: buildProfile, cas, cache: cachePolicy } = buildPlan;
-	const useBuildCache = cachePolicy.read;
-	let androidPackage = initialPackage;
-	let ccacheActivity = CCACHE_NOT_RUN;
-	let phaseFailure = 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 { abi: buildAbi, runOptions: buildRunOptions, remoteRunOptions } = androidBuildOptions({
-		release,
-		physical,
-		device,
-		variant,
-		deviceAbi,
-		compiler: cas?.id,
-		buildProfile,
-		targetAbiOnly: buildPlan.targetAbiOnly,
-		hostedAbi
-	});
-	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;
-	let handoff = null;
-	let swapFellBack = false;
-	async function resolveInitialFingerprint() {
-		if (easBuild?.ok) {
-			hash = storeHash = easBuild.fingerprint;
-			cacheKey = storeKey = easBuild.cacheKey;
-			apkPath = easBuild.path;
-			record.fingerprint = hash;
-			record.cacheKey = cacheKey;
-			record.cacheHit = easBuild.cacheHit;
-			record.cacheSkipped = !useBuildCache;
-			providerName = "eas";
-			stats.setCacheKey(cacheKey);
-			return true;
-		}
-		if (useBuildCache) step("cache-lookup");
-		const fingerprintTimer = stepTimer(now);
-		try {
-			const computed = await fingerprint(root, { platform: PLATFORM });
-			hash = computed?.hash ?? "";
-			fingerprintSources = computed?.sources ?? [];
-		} catch (err) {
-			const message = String(err?.message || err);
-			record.cacheSkipped = !useBuildCache;
-			record.missReason = fingerprintErrorMissReason(message);
-			phaseFailure = fail$1(NO_FINGERPRINT, `@expo/fingerprint could not fingerprint ${root}: ${message}`, "Fix the @expo/fingerprint error above, then retry.", { lastBuildStatus: true });
-			return false;
-		}
-		if (!hash) {
-			record.cacheSkipped = !useBuildCache;
-			record.missReason = fingerprintErrorMissReason("no hash");
-			phaseFailure = fail$1(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.", { lastBuildStatus: true });
-			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;
-		phase("fingerprint", `${shortHash(hash)} ${cached ? "hit" : "miss"}${useBuildCache ? "" : !requestedBuildCache ? " (--no-build-cache)" : " (cache reuse off in config)"} ${fingerprintTimer()}`);
-		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;
-	}
-	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()}`);
-		}
-	}
-	let waitedForBuild = null;
-	let releasedWait = null;
-	async function awaitSharedBuild() {
-		const shared = await waitForSharedBuild({
-			platform: PLATFORM,
-			key: cacheKey,
-			fingerprint: hash,
-			root,
-			logFile: buildLog,
-			command: "stim android",
-			acquire: acquireLock,
-			wait: waitForBuild,
-			now,
-			phase: (text) => {
-				step("wait");
-				phase("build", text);
-			},
-			waitingOn,
-			warn: (text) => phase("build", chalk.yellow(text)),
-			out
-		});
-		if (shared.refusal) {
-			const { code, message, remedy } = shared.refusal;
-			phaseFailure = fail$1(code, message, remedy, { lastBuildStatus: true });
-			throw new ArtifactRefusal(phaseFailure);
-		}
-		buildLock = shared.lock;
-		releasedWait = shared.released;
-		if (shared.hit) {
-			apkPath = shared.hit.path;
-			record.cacheHit = "local";
-			waitedForBuild = shared.hit.waited;
-		}
-		return apkPath;
-	}
-	let swapDir = null;
-	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(cachedPath) {
-		const prepared = await installableCachedApk(cacheKey, cachedPath);
-		if (!prepared) {
-			record.cacheHit = false;
-			waitedForBuild = null;
-		}
-		return prepared;
-	}
-	function reasonForMiss(rekeyedBy) {
-		if (swapFellBack) return {
-			reason: skippedMissReason("the cached APK could not be reused, so this run built it fresh"),
-			diff: null
-		};
-		if (!useBuildCache) return {
-			reason: skippedMissReason(requestedBuildCache ? "cache reuse off in config" : "cache reuse turned off by --no-build-cache"),
-			diff: null
-		};
-		const current = {
-			hash: storeHash,
-			sources: storeSources
-		};
-		const explained = explainBuildMiss({
-			root,
-			platform: PLATFORM,
-			current,
-			rekeyedBy,
-			baselineDeps: { readState }
-		});
-		return {
-			reason: explained.reason,
-			diff: explained.previousHash && explained.changedNames.length ? fingerprintDiffRecord({
-				changed: explained.changedNames,
-				previousHash: explained.previousHash,
-				hash: current.hash
-			}) : null
-		};
-	}
-	function explainMiss(rekeyedBy) {
-		const explained = reasonForMiss(rekeyedBy);
-		record.missReason = explained.reason;
-		if (explained.diff) writer.write(explained.diff);
-		miss(record.missReason);
-		phase("cache", `miss: ${record.missReason.summary}`);
-		if (record.missReason.kind === "no-baseline") {
-			const line = untrackedMissLine(untracked({ projectRoot: root }));
-			if (line) phase("fingerprint", chalk.dim(line));
-		}
-	}
-	async function takeBuildSlot() {
-		requireLocalBuild(buildMachine);
-		if (!maxBuilds) return true;
-		try {
-			buildSlot = await acquireSlot({
-				automatic: buildMachine === "auto",
-				max: maxBuilds,
-				root,
-				logFile: buildLog,
-				out,
-				waitingFor: (info) => waitingFor?.(info, "build-slot")
-			});
-			slotWaitMs = buildSlot.slotWaitMs;
-		} catch (err) {
-			requireLocalBuild(buildMachine);
-			const refusal = (0, ownership_claim_exports.claimFailure)(err, "stim android");
-			if (refusal) {
-				phaseFailure = fail$1(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`));
-		}
-		return true;
-	}
-	/** Whether this build should leave this Mac, before any machine is asked; null builds here. */
-	function placeBuild() {
-		const { mode, machines, localEnabled } = buildPlacementCandidates(buildMachine);
-		if (localEnabled && machines.length === 0 && !namedBuildMachine(buildMachine) && buildMachine !== "local") return null;
-		const unsupported = physical ? "device builds build here" : remoteTarget ? "remote device builds build here" : release ? `${variant} builds build here` : cas ? "Apple Clang CAS builds build here" : !cachePolicy.write ? "the build cache is off" : null;
-		const here = machineCapacity();
-		const placement = offloadPlacement({
-			mode,
-			localEnabled,
-			machines: machines.length,
-			here,
-			unsupported,
-			selected: buildMachine
-		});
-		if (!placement.offload) {
-			hereReason = placement.reason;
-			writer.write(buildPlacementRecord({
-				platform: PLATFORM,
-				buildMachine,
-				stays: {
-					code: placement.code,
-					reason: placement.reason
-				}
-			}));
-			if (mode !== "off") phase("build", `placement: here (${placement.reason})`);
-			return null;
-		}
-		return {
-			mode,
-			here,
-			code: placement.code,
-			reason: placement.reason,
-			machines
-		};
-	}
-	const openOffload = { choice: null };
-	/** Asks the paired machines once the post-mutation key is known; null builds here. */
-	async function chooseMachine(candidate) {
-		let asked = [];
-		const choice = await chooseBuildMachine({
-			projectRoot: root,
-			target: {
-				platform: "android",
-				local: androidToolchain(),
-				requires: androidRequirements(root)
-			},
-			mode: candidate.mode,
-			here: candidate.here,
-			note: (line) => phase("build", chalk.dim(`offload: ${line}`)),
-			machines: candidate.machines,
-			selected: buildMachine,
-			onCandidates: (each) => asked = each
-		});
-		if (typeof choice === "string") {
-			const only = candidate.machines.length === 1 ? candidate.machines[0].machine : null;
-			if (only && choice.startsWith(`${only}: `)) fallbackMachine = only;
-			fallBack(choice, choice, {
-				code: "no-remote-mac-took-it",
-				candidates: asked
-			});
-			return null;
-		}
-		openOffload.choice = choice;
-		writer.write(buildPlacementRecord({
-			platform: PLATFORM,
-			buildMachine,
-			candidates: asked,
-			chose: {
-				machine: choice.machine,
-				reason: `${candidate.reason}${placementLoad(choice)}`
-			}
-		}));
-		phase("build", `placement: ${choice.machine} (${candidate.reason}${placementLoad(choice)})`);
-		return choice;
-	}
-	/** Builds on the chosen machine and stores the APK under the post-mutation key; false builds here instead unless a machine was named. */
-	async function compileElsewhere(choice, candidate) {
-		if (!storeKey || !storeHash) {
-			const reason = "the build fingerprint or cache key is unavailable";
-			if (namedBuildMachine(buildMachine)) fallBack(reason, reason, { machine: choice.machine });
-			else writer.write(buildPlacementRecord({
-				platform: PLATFORM,
-				buildMachine,
-				event: "placement_fallback",
-				fallback: {
-					code: "fallback",
-					reason,
-					machine: choice.machine
-				}
-			}));
-			return false;
-		}
-		const stagingDir = join(workspaceDir(root), "offload", PLATFORM);
-		const outcome = await offloadBuild({
-			choice,
-			expectedFingerprint: storeHash,
-			request: {
-				platform: "android",
-				isExpo,
-				android: {
-					variant,
-					abi: buildAbi,
-					gradleBuildCache: buildPlan.gradleBuildCache,
-					pch: buildPlan.pch,
-					compilerCache: buildPlan.compilerCache === "none" ? "none" : "ccache"
-				}
-			},
-			stagingDir,
-			onPhase: (name, msg) => phase(name, remotePhaseText(name, msg, choice.machine)),
-			onEnter: (name) => {
-				if (name === "compile" || name === "build" || name === "prebuild" || name === "pods") record.builtOn = choice.machine;
-				place({
-					host: choice.machine,
-					phase: name
-				});
-				step(name === "prebuild" ? name : "compile");
-			},
-			onRecord: (entry) => writer.write({
-				...entry,
-				offloadedTo: choice.machine
-			}),
-			note: (line) => phase("build", line)
-		});
-		place(null);
-		let stored = null;
-		let reason = outcome.ok ? null : outcome.reason;
-		if (outcome.ok) {
-			const settled = await refingerprintAfterMutation({
-				projectRoot: root,
-				platform: PLATFORM,
-				previousHash: storeHash,
-				fingerprint
-			});
-			if (!settled || settled.moved) reason = "the checkout here changed while it built";
-			else try {
-				stored = storeCached(PLATFORM, storeKey, outcome.artifactPath, {
-					sources: storeSources,
-					overwrite: !useBuildCache
-				});
-			} catch (err) {
-				reason = `could not store the APK: ${err?.message || err}`;
-			}
-		}
-		try {
-			rmSync(stagingDir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-		step("compile");
-		if (!outcome.ok || !stored) {
-			const why = reason ?? "the APK was not stored";
-			fallbackMachine = choice.machine;
-			fallBack(`${choice.machine}: ${why}`, `offload failed: ${why}`, {
-				code: "offload-failed",
-				machine: choice.machine
-			});
-			writer.write({
-				src: "build",
-				level: "warn",
-				event: "offload_failed",
-				msg: reason,
-				machine: choice.machine
-			});
-			return false;
-		}
-		const { timings } = outcome;
-		apkPath = stored;
-		handoff = outcome.handoff ?? null;
-		record.builtOn = outcome.machine;
-		record.offloadedTo = outcome.machine;
-		stats.setPlacement({
-			decision: "offloaded",
-			machine: outcome.machine,
-			reason: `${candidate.reason}${placementLoad(choice)}`,
-			buildMs: timings.totalMs
-		});
-		ccacheActivity = outcome.ccache;
-		phase("build", `built on ${outcome.machine} in ${formatDuration(timings.totalMs)}: offer ${formatDuration(timings.offerMs)}, sync ${formatDuration(timings.syncMs)}, build ${formatDuration(timings.workerMs)}, fetch ${formatDuration(timings.fetchMs)}`);
-		phase("cache", `compilation cache on ${outcome.machine} ${ccacheActivityLine(ccacheActivity)}`);
-		writer.write({
-			src: "build",
-			level: "info",
-			event: "offload_done",
-			msg: `built on ${outcome.machine}`,
-			timings
-		});
-		return true;
-	}
-	async function prepareSource() {
-		const rekeyedBy = [];
-		const prebuildPlan = planPrebuildFor(root, PLATFORM, {
-			isExpo,
-			fingerprint: hash,
-			sources: fingerprintSources
-		});
-		const prebuildRan = prebuildPlan === "generate" || prebuildPlan === "regenerate";
-		if (prebuildPlan === "refuse") {
-			const refusal = staleNativeDirRefusal(PLATFORM);
-			phaseFailure = fail$1(refusal.code, refusal.message, refusal.remedy, { lastBuildStatus: true });
-			throw new ArtifactRefusal(phaseFailure);
-		}
-		if (prebuildRan) {
-			miss(reasonForMiss([]).reason, true);
-			step("prebuild");
-			recordPrebuild(root, PLATFORM, null);
-			const pre = await prebuild(root, PLATFORM, writer, {
-				isExpo,
-				clean: prebuildPlan === "regenerate"
-			});
-			if (pre.failed) {
-				phaseFailure = fail$1(pre.code, pre.reason, pre.remedy, {
-					lastBuildStatus: true,
-					lines: tail(pre.lastLines),
-					logPath: displayPath(root, buildLog)
-				});
-				throw new ArtifactRefusal(phaseFailure);
-			}
-			phase("prebuild", `${prebuildPlan === "generate" ? "android/ generated" : "android/ not generated from this fingerprint -> regenerated with --clean"} (${formatDuration(pre.durationMs)})`);
-			androidPackage = detectAndroidPackage(root) || androidPackage;
-			record.bundleId = androidPackage;
-		}
-		return {
-			prebuildRan,
-			rekeyedBy,
-			editedConfig: []
-		};
-	}
-	async function revalidateSource(preparation) {
-		const { prebuildRan, rekeyedBy } = preparation;
-		if (prebuildRan) {
-			const after = await refingerprintAfterMutation({
-				projectRoot: root,
-				platform: PLATFORM,
-				previousHash: hash,
-				fingerprint
-			});
-			preparation.editedConfig = after ? configInputsChanged(fingerprintSources, after.sources, { prebuildRan }) : [];
-			const { editedConfig } = preparation;
-			if (after && !editedConfig.length) recordPrebuild(root, PLATFORM, after.hash);
-			if (after?.moved && !editedConfig.length) {
-				rekeyedBy.push("prebuild");
-				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";
-						lateHit();
-						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 -- stim guide lifecycle concurrency`);
-						}
-					}
-				}
-			}
-		}
-		return apkPath ? { ready: apkPath } : null;
-	}
-	async function acquireRemoteArtifact(offload, { rekeyedBy, editedConfig }) {
-		explainMiss(rekeyedBy);
-		step("compile");
-		if (editedConfig.length) fallBack("prebuild changed config inputs, so the APK cannot be cached", "offload failed: prebuild changed config inputs, so the APK cannot be cached");
-		else {
-			const choice = await chooseMachine(offload);
-			if (choice) await compileElsewhere(choice, offload);
-		}
-		return apkPath ? { ready: apkPath } : null;
-	}
-	async function compileHere(offload, { rekeyedBy }) {
-		if (!offload) {
-			explainMiss(rekeyedBy);
-			step("compile");
-		}
-		if (offload) stats.setPlacement({
-			decision: "fell-back",
-			slotWaitMs,
-			deviceSlotWaitMs: stats.deviceSlotWaitMs(),
-			reason: record.offloadFallback ?? "offload failed",
-			...fallbackMachine ? { machine: fallbackMachine } : {}
-		});
-		else stats.setPlacement({
-			decision: "here",
-			reason: hereReason,
-			slotWaitMs,
-			deviceSlotWaitMs: stats.deviceSlotWaitMs()
-		});
-		requireLocalBuild(buildMachine);
-		record.builtOn = "here";
-		phase("build", `compiling ${variant || "debug"} with Gradle`);
-		const built = await build({
-			root,
-			logWriter: writer,
-			variant,
-			abi: buildAbi
-		}, {
-			estimateMs: estimates().coldBuildMs,
-			ccache: buildPlan.compilerCache === "ccache" ? ccacheFor({
-				root,
-				onNote: out
-			}) : null,
-			cas,
-			buildCache: buildPlan.gradleBuildCache,
-			pch: buildPlan.pch,
-			compilerCacheDisabled: buildPlan.compilerCache === "none"
-		});
-		ccacheActivity = built.ccache ?? CCACHE_UNAVAILABLE;
-		phase("cache", `compilation cache ${ccacheActivityLine(ccacheActivity)}`);
-		if (!built.ok) {
-			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) extracted.push(`... and ${built.truncated} more diagnostic(s) in the log`);
-			phaseFailure = fail$1(built.code, built.reason, diagnostics.find((d) => d.remedy)?.remedy || built.remedy || null, {
-				lastBuildStatus: true,
-				diagnostics: extracted,
-				buildDiagnostics: diagnostics,
-				lines: extracted.length ? [] : tail(built.lastLines),
-				logPath: displayPath(root, buildLog)
-			});
-			throw new ArtifactRefusal(phaseFailure);
-		}
-		apkPath = built.apkPath;
-		stats.setBuildMs(built.durationMs);
-		phase("build", `ok (${formatDuration(built.durationMs)})`);
-		if (built.apkNote) phase("build", chalk.yellow(built.apkNote));
-		return apkPath;
-	}
-	async function validateCompiled({ prebuildRan, editedConfig }) {
-		const beforeBuildHash = storeHash;
-		const afterBuild = editedConfig.length ? null : await refingerprintAfterMutation({
-			projectRoot: root,
-			platform: PLATFORM,
-			previousHash: beforeBuildHash,
-			fingerprint
-		});
-		const changedDuringBuild = afterBuild ? inputsChangedDuringBuild({
-			platform: PLATFORM,
-			lookup: fingerprintSources,
-			prebuildRan,
-			compiled: storeSources,
-			current: afterBuild.sources
-		}) : editedConfig;
-		if (!afterBuild || changedDuringBuild.length) {
-			record.fingerprint = null;
-			record.cacheKey = null;
-			phase("fingerprint", chalk.yellow(changedDuringBuild.length ? changedDuringBuildLine(changedDuringBuild) : "unavailable after Gradle; the build will be installed but not cached"));
-			return "uncacheable";
-		}
-		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)`));
-		}
-		return "cacheable";
-	}
-	async function storeArtifact(artifactPath) {
-		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: artifactPath,
-					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: artifactPath,
-			runOptions: remoteRunOptions
-		});
-	}
-	try {
-		apkPath = await runArtifactLifecycle({
-			resolve: async () => {
-				if (!await resolveInitialFingerprint()) throw new ArtifactRefusal(phaseFailure);
-				if (easBuild) return {
-					kind: "ready",
-					artifact: apkPath
-				};
-				await resolveRemoteArtifact();
-				if (apkPath) return {
-					kind: "cached",
-					artifact: apkPath
-				};
-				miss(reasonForMiss([]).reason);
-				return { kind: "miss" };
-			},
-			claim: useBuildCache ? awaitSharedBuild : void 0,
-			reuse: async (cached) => {
-				apkPath = await prepareCachedArtifact(cached);
-				if (apkPath) lateHit();
-				else if (swapFellBack) miss(reasonForMiss([]).reason);
-				return apkPath;
-			},
-			build: {
-				placement: {
-					select: placeBuild,
-					acquire: acquireRemoteArtifact
-				},
-				admit: async () => {
-					if (!await takeBuildSlot()) throw new ArtifactRefusal(phaseFailure);
-				},
-				prepare: prepareSource,
-				revalidate: revalidateSource,
-				compile: compileHere,
-				validate: validateCompiled,
-				store: storeArtifact
-			},
-			release: () => {
-				if (openOffload.choice) closeOffload(openOffload.choice);
-				releaseHeldLock();
-				releaseHeldSlot();
-			}
-		});
-	} catch (error) {
-		if (error instanceof OffloadRefusal) {
-			const { code, message, remedy } = error;
-			return {
-				ok: false,
-				failure: fail$1(code, message, remedy, { lastBuildStatus: true }),
-				ccache: ccacheActivity
-			};
-		}
-		if (error instanceof ArtifactRefusal) return {
-			ok: false,
-			failure: error.failure,
-			ccache: ccacheActivity
-		};
-		throw error;
-	}
-	return {
-		ok: true,
-		artifact: {
-			apkPath,
-			handoff,
-			androidPackage,
-			swapDir,
-			waitedForBuild,
-			ccache: ccacheActivity,
-			uploadPending,
-			providerUpload,
-			providerName,
-			remote,
-			abandonedRemote
-		}
-	};
-}
-function tail(lines, n = FALLBACK_LINES) {
-	return (Array.isArray(lines) ? lines : []).slice(-n);
-}
-//#endregion
-//#region src/commands/android/collector.ts
-function collectorEntry() {
-	return spawnEntry("collector-run");
-}
-function collectorLogFile(root, slot = "default") {
-	return join(workspaceLogsDir$1(root), `collector-${deviceSlotFileKey(PLATFORM, slot)}.log`);
-}
-const COLLECTOR_EXIT_WAIT_MS = 2e3;
-const COLLECTOR_POLL_MS = 25;
-function killPreviousCollector(root, { platform = PLATFORM, slot = "default", kill = (pid, signal) => signalProcessTree(pid, signal), collectors = null, verify = verifyCollectorOwnership, isAlive = pidExists, note = (_line) => {} } = {}) {
-	const record = (collectors ?? readCollectors(root))?.[deviceSlotKey(platform, slot)];
-	const pid = Number(record?.pid);
-	if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return null;
-	const ownership = verify({
-		pid,
-		platform: deviceSlotKey(platform, slot),
-		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, slot = "default", 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, {
-		slot,
-		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$1(root), { recursive: true });
-		const fd = openSync(collectorLogFile(root, slot), "a");
-		stdio = [
-			"ignore",
-			fd,
-			fd
-		];
-	} catch {}
-	try {
-		const child = spawn(process.execPath, [
-			collectorEntry(),
-			"--platform",
-			PLATFORM,
-			"--root",
-			root,
-			...slot === "default" ? [] : ["--slot", slot],
-			"--serial",
-			serial,
-			"--package",
-			packageName
-		], {
-			cwd: androidToolCwd() ?? 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
-function androidProcessRuntime(prepare) {
-	return {
-		prepare,
-		scheme: () => void 0,
-		verificationWaitMs: RELEASE_VERIFY_WAIT_MS,
-		launch: async (_prepared, { serial, androidPackage, remoteDevice, launchRelease }) => remoteDevice ? remoteDevice.launch({
-			serial,
-			packageName: androidPackage,
-			metroPort: null
-		}) : launchRelease({
-			serial,
-			packageName: androidPackage
-		}),
-		verify: async (_prepared, context) => verifyAndroidProcessRun(context)
-	};
-}
-function androidMetroRuntime(prepare) {
-	return {
-		prepare,
-		scheme: (root, apkPath, resolve) => resolve(root, apkPath),
-		verificationWaitMs: DEBUG_VERIFY_STEP_MS,
-		launch: async ({ metroPort }, { serial, androidPackage, scheme, physical, launch }) => launch({
-			serial,
-			packageName: androidPackage,
-			metroPort: metroPort ?? 8081,
-			devClientScheme: scheme,
-			physical
-		}),
-		verify: async ({ metroPort }, context) => verifyAndroidMetroRun({
-			...context,
-			metroPort
-		})
-	};
-}
-async function verifyAndroidProcessRun({ root, slot, remoteDevice, verifyReleaseLaunched, serial, androidPackage, variant, logsDir, launchedAt, phase }) {
-	const readNativeCrashes = () => remoteDevice ? [] : captureNativeCrashes({
-		root,
-		slot,
-		platform: "android",
-		deviceId: serial,
-		appId: androidPackage,
-		since: launchedAt
-	}, logsDir);
-	if (remoteDevice) {
-		phase("verify", chalk.yellow("UNVERIFIED: remote adapter launch accepted; process verification is unavailable"));
-		return { state: LAUNCH_UNVERIFIED };
-	}
-	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 };
-}
-async function verifyAndroidMetroRun({ root, slot, remoteDevice, verifyLaunched, serial, androidPackage, metroCheck, logsDir, launchedAt, metroPort, isExpo, physical, device, scheme, component = null, phase }) {
-	const runCommand = nativeRunCommand("android", slot, {
-		physical,
-		deviceId: serial
-	});
-	const readNativeCrashes = () => remoteDevice ? [] : captureNativeCrashes({
-		root,
-		slot,
-		platform: "android",
-		deviceId: serial,
-		appId: androidPackage,
-		since: launchedAt
-	}, logsDir);
-	const freshEmulator = Boolean((device.created || device.adoptionPending) && device.owned && !remoteDevice);
-	const timeoutMs = freshEmulator ? 6e4 : VERIFY_TIMEOUT_MS;
-	if (metroCheck && freshEmulator) phase("verify", `waiting up to 60s for bundle load (${device.created ? "new" : "adopted"} emulator)`);
-	const siblings = metroCheck ? siblingPlatformSlots(root, "android", slot) : [];
-	const verification = metroCheck ? await verifyLaunched({
-		timeoutMs,
-		requireBundleResponse: true,
-		slot: launchSlotScope(root, slot),
-		platformShared: siblings.length > 0,
-		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 run \`${runCommand}\` again; it force-stops a crashed process that remains 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 \`${runCommand}\` 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 \`${runCommand}\` 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 };
-	}
-	if (verification?.unattributed) {
-		const [headline, ...lines] = unattributedLaunchLines({
-			platform: "android",
-			metroPort,
-			slot,
-			siblings
-		});
-		phase("verify", chalk.yellow(headline));
-		for (const line of lines) phase("", chalk.yellow(line));
-		return {
-			state: LAUNCH_UNVERIFIED,
-			unattributed: true
-		};
-	}
-	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,
-		devClient: Boolean(scheme),
-		mode: isExpo ? MODE_EXPO : MODE_BARE
-	})) phase("", chalk.yellow(line));
-	return { state: LAUNCH_UNVERIFIED };
-}
-const ADOPTED_INSTALL_HEADROOM_BYTES = 536870912;
-const INSUFFICIENT_STORAGE = /INSTALL_FAILED_INSUFFICIENT_STORAGE/;
-async function wipeAdoptedAvd(room, free) {
-	room.phase("device", chalk.yellow(`${room.avdName} has ${free === null ? "too little space" : `${formatBytes(free)} free`} on /data after removing other apps and trimming caches; wiping its user data`));
-	const expectedRecord = deviceSlotPlatforms(loadConfig$1()?.projects?.[room.root], room.slot)?.android;
-	if (!expectedRecord?.adoptionPending || expectedRecord.avdName !== room.avdName) throw new Error("the emulator assignment changed before the wipe; its data was kept");
-	const wiped = room.wipeDevice(room.avdName, {
-		wipe: true,
-		owner: {
-			projectPath: room.root,
-			slot: room.slot,
-			expectedRecord
-		},
-		workspace: room.root
-	});
-	if (wiped.status !== "torn-down") throw new Error(`could not wipe it: ${wiped.reason ?? wiped.status}`);
-	const rebooted = await room.rebootDevice();
-	if (!rebooted.ok || !rebooted.serial) throw new Error(`it did not boot after its user data was wiped: ${rebooted.reason ?? "no serial"}`);
-	if (room.resolveAvdSerial(room.avdName).serial !== rebooted.serial) throw new Error(`${rebooted.serial} is not running ${room.avdName} after the wipe`);
-	room.phase("device", `${room.avdName} (${rebooted.serial}) booted with wiped user data`);
-	return rebooted.serial;
-}
-async function installOnAdoptedAvd(room, serial, installApk) {
-	const neededBytes = 2 * statSync(room.apkPath).size + ADOPTED_INSTALL_HEADROOM_BYTES;
-	const roomy = (free) => free === null || free >= neededBytes;
-	const outOfSpace = (result) => Boolean(result.failed) && INSUFFICIENT_STORAGE.test(result.reason ?? "");
-	let target = serial;
-	let wiped = false;
-	if (!roomy(room.dataFreeBytes(target))) {
-		room.trimCaches(target, neededBytes);
-		const free = room.dataFreeBytes(target);
-		if (roomy(free)) room.phase("install", `trimmed app caches on ${room.avdName} to make room for the APK`);
-		else {
-			target = await wipeAdoptedAvd(room, free);
-			wiped = true;
-		}
-	}
-	let installed = installApk(target);
-	if (wiped || !outOfSpace(installed)) return {
-		serial: target,
-		installed
-	};
-	room.trimCaches(target, neededBytes);
-	installed = installApk(target);
-	if (!outOfSpace(installed)) return {
-		serial: target,
-		installed
-	};
-	target = await wipeAdoptedAvd(room, room.dataFreeBytes(target));
-	return {
-		serial: target,
-		installed: installApk(target)
-	};
-}
-async function resolveInstallSerial({ root, slot, device, physical, remoteDevice, serial, resolveAvdSerial, waitForDeviceBoot, phase }) {
-	if (physical || remoteDevice || !device.owned || !device.avdName) return serial;
-	const resolved = resolveAvdSerial(device.avdName, { timeoutMs: 5e3 });
-	if (!resolved.serial) throw new Error(`Could not verify a running owned AVD ${device.avdName} before installation.`);
-	if (resolved.serial !== serial) {
-		phase("device", `${device.avdName} changed serial (${serial} -> ${resolved.serial}); checking readiness before installation`);
-		const ready = await waitForDeviceBoot(resolved.serial, 6e4, { commandTimeoutMs: 5e3 });
-		if (!ready.ok) throw new Error(`Emulator ${resolved.serial} never reported boot completion. Diagnostic: ${JSON.stringify(ready.diagnostic)}`);
-		if (resolveAvdSerial(device.avdName, { timeoutMs: 5e3 }).serial !== resolved.serial) throw new Error(`Could not verify AVD ${device.avdName} still runs on ${resolved.serial} after checking readiness.`);
-		phase("device", `reopen agent-device on ${resolved.serial}`);
-	}
-	const consolePort = Number(resolved.serial.replace(/^emulator-/, ""));
-	withConfigLock$1(() => {
-		const current = deviceSlotPlatforms(loadConfig$1()?.projects?.[root], slot)?.android;
-		if (!current?.owned || current.avdName !== device.avdName) throw new Error("The owned emulator assignment changed before installation.");
-		if (current.consolePort !== consolePort) setDevice(root, PLATFORM, {
-			...current,
-			consolePort
-		}, slot);
-	});
-	return resolved.serial;
-}
-async function finishAndroidRun({ runtime, runtimePreparation, lease, releaseLease, root, slot, json, metroCheck, useBuildCache, variant, release, isExpo, metroPort, logsDir, emuLog, device, physical, remoteDevice, bootPromise, resolveAvdSerial, waitForDeviceBoot, 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, recordBuild, now, out, emit, recordRun, reclaimed, devServer, enterPhase, rebootDevice, dataFreeBytes = androidDataFreeBytes, trimCaches = trimAndroidCaches, wipeDevice = teardownOwnedAvd }) {
-	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;
-	};
-	enterPhase("device");
-	const booted = await bootPromise;
-	const runCommand = nativeRunCommand("android", slot, {
-		physical,
-		deviceId: booted.serial
-	});
-	if (booted.failed) {
-		const diag = diagnoseBootFailure(booted, emuLog, runCommand, physical);
-		return fail(diag.code, diag.message, diag.remedy, {
-			lines: diag.lines,
-			logPath: diag.logPath ? displayPath(root, diag.logPath) : null
-		});
-	}
-	let serial;
-	try {
-		serial = await resolveInstallSerial({
-			root,
-			slot,
-			device,
-			physical,
-			remoteDevice,
-			serial: booted.serial,
-			resolveAvdSerial,
-			waitForDeviceBoot,
-			phase
-		});
-	} catch (error) {
-		return fail(NO_DEVICE, error instanceof Error ? error.message : String(error), `Run \`stim status\` to inspect the owned AVD, then retry \`${runCommand}\`; the APK was not installed.`);
-	}
-	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;
-	enterPhase("install");
-	let installTimer = stepTimer(now);
-	const installApk = (target) => {
-		installTimer = stepTimer(now);
-		return install({
-			serial: target,
-			apkPath,
-			packageName: androidPackage,
-			allowUninstall: release || adopting
-		});
-	};
-	let installed;
-	if (adopting && device.avdName && apkPath) {
-		const room = {
-			root,
-			slot,
-			avdName: device.avdName,
-			apkPath,
-			phase,
-			rebootDevice,
-			dataFreeBytes,
-			trimCaches,
-			wipeDevice,
-			resolveAvdSerial
-		};
-		try {
-			({serial, installed} = await installOnAdoptedAvd(room, serial, installApk));
-		} catch (error) {
-			return fail(INSTALL_FAILED, `Could not make room on adopted emulator ${device.avdName}: ${String(error?.message || error)}`, `Run \`${runCommand}\` again; adoption remains pending, so it retries the cleanup.`);
-		}
-	} else installed = installApk(serial);
-	if (installed.failed) {
-		const installRemedy = remoteDevice?.failureRemedy() ?? localInstallRemedy({
-			reason: installed.reason,
-			packageName: androidPackage,
-			serial,
-			useBuildCache
-		});
-		return fail(installed.code || "STIM_INSTALL_FAILED", installed.reason, installRemedy, { lastBuildStatus: true });
-	}
-	if (adopting) try {
-		withConfigLock$1(() => {
-			const config = loadConfig$1();
-			const current = deviceSlotPlatforms(config?.projects?.[root], slot)?.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 = runtime.scheme(root, apkPath, resolveDevClientScheme);
-	enterPhase("launch");
-	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 = await runtime.launch(runtimePreparation, {
-		serial,
-		androidPackage,
-		scheme,
-		physical,
-		remoteDevice,
-		launch,
-		launchRelease
-	});
-	if (launched.failed) {
-		printNativeCrashReport({
-			root,
-			slot,
-			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, launchRemedy(remoteDevice, serial, 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}`) + restartedAppNote(launched.restartedPid, "; ")
-	});
-	phase("launch", `${androidPackage}${restartedAppNote(launched.restartedPid)} ${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}`)));
-	}
-	if (!release) reportMetroRoute({
-		launched,
-		remote: Boolean(remoteDevice),
-		metroPort,
-		androidPackage,
-		serial,
-		phase,
-		writer
-	});
-	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({
-		recordBuild,
-		root,
-		record,
-		startedAt,
-		durationMs: now() - started,
-		status: "ok",
-		out
-	});
-	const remoteRelease = Boolean(remoteDevice && release);
-	if (remoteDevice) {
-		killPreviousCollector(root, {
-			slot,
-			kill,
-			isAlive: pidAlive,
-			verify: verifyCollector,
-			note: (line) => out(phaseLine("logs", line))
-		});
-		writer.write({
-			src: "build",
-			level: "info",
-			event: "collector_skipped",
-			msg: `remote session ${serial}: device logs come from agent-device/EAS, so no adb logcat collector is attached`
-		});
-	} else {
-		if (physical) raiseLeaseFor(0, false);
-		const collectorPid = await startCollector({
-			root,
-			slot,
-			serial,
-			packageName: androidPackage,
-			spawn,
-			kill,
-			alive: pidAlive,
-			verify: verifyCollector,
-			out
-		});
-		phase("logs", `${displayPath(root, logsDir)}${collectorPid ? ` (collector pid ${collectorPid})` : ""}`);
-	}
-	if (physical) raiseLeaseFor(runtime.verificationWaitMs, false);
-	const { state: launchState, warning: launchWarning, unattributed } = await runtime.verify(runtimePreparation, {
-		root,
-		slot,
-		remoteDevice: Boolean(remoteDevice),
-		verifyReleaseLaunched,
-		verifyLaunched,
-		serial,
-		androidPackage,
-		variant,
-		metroCheck,
-		logsDir,
-		launchedAt,
-		metroPort,
-		isExpo,
-		physical,
-		device,
-		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,
-		unattributed
-	}));
-	const leaseFacts = lease?.facts() ?? null;
-	releaseLease();
-	const facts = reportAndroidResult({
-		root,
-		slot,
-		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,
-		reclaimed,
-		devServer,
-		links: workspaceLinks(root, {
-			platform: "android",
-			slot
-		})
-	});
-	if (remoteWasAbandoned || uploadWasAbandoned) exitAfterFlush(0);
-	return {
-		ok: true,
-		facts
-	};
-}
-function localInstallRemedy({ reason, packageName, serial, useBuildCache }) {
-	const conflict = installConflictKind(reason);
-	if (!conflict) return `Check that ${serial} is still connected (\`adb devices\`) and has room for the APK.`;
-	const rerun = useBuildCache ? " Then run this command again; it installs the APK from cache without building it again." : " Then run this command again.";
-	return `${packageName} is already installed on ${serial} ` + (conflict === "signature" ? "with a different signer" : "at a higher versionCode") + `. Uninstall it first (\`adb -s ${serial} uninstall ${packageName}\`); its data goes with it.` + rerun;
-}
-function launchRemedy(remoteDevice, serial, packageName) {
-	return remoteDevice?.failureRemedy() ?? `Check the app installed correctly (\`adb -s ${serial} shell pm list packages ${packageName}\`).`;
-}
-function reportMetroRoute({ launched, remote, metroPort, androidPackage, serial, phase, writer }) {
-	if (remote) {
-		phase("metro", `public origin ${launched.jsLocation}`);
-		return;
-	}
-	const reversedSummary = (launched.reversed ?? []).join(", ") || `tcp:${metroPort}->tcp:${metroPort}`;
-	if (launched.debugHttpHost) {
-		phase("metro", `debug_http_host ${launched.debugHttpHost} + adb reverse ${reversedSummary}`);
-		return;
-	}
-	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"}`
-	});
-}
-function diagnoseBootFailure(booted, logFile, runCommand, physical) {
-	if (booted.code) return {
-		code: booted.code,
-		message: booted.reason ?? "The emulator did not boot.",
-		remedy: booted.remedy ?? null,
-		lines: [],
-		logPath: null
-	};
-	const diag = noDeviceDiagnostic({
-		reason: booted.reason ?? "The emulator did not boot.",
-		logFile,
-		remedy: booted.remedy ?? `Run \`stim status\` to see what Stim thinks it owns; re-running \`${runCommand}\` creates a fresh owned AVD.`,
-		localEmulator: !physical
-	});
-	return {
-		code: NO_DEVICE,
-		...diag
-	};
-}
-//#endregion
-//#region src/commands/android/plan.ts
-function slotOwnedAvd(projectPath, slot) {
-	const android = deviceSlotPlatforms(getProject(projectPath), slot)?.android;
-	if (!android?.owned || !android.avdName || android.setupIncomplete) return null;
-	const systemImage = ownedAvdSystemImage(android.avdName);
-	return systemImage ? {
-		avdName: android.avdName,
-		systemImage,
-		deviceProfile: ownedAvdDeviceProfile(android.avdName)
-	} : null;
-}
-function fail(code, message, remedy, { lines = [] } = {}) {
-	return {
-		ok: false,
-		code,
-		message,
-		remedy,
-		lines
-	};
-}
-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 resolveAndroidRunPlan({ settings, settingsContext, slot, easProfile, variant: variantFlag, systemImage: systemImageFlag, deviceProfile: deviceProfileFlag, device: deviceFlag, wait: waitFlag, waitConflict, remote: commandRemoteBackend, buildCache: requestedBuildCache }, { warn, resolveCompilerCache = androidCompilerCache, resolveCacheProvider = resolveCacheProviderConfig, validateAvdConfig = androidAvdConfigSettingError, readFlavors = readProductFlavors, detectExpo = detectIsExpo, listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfiles, parkedLimit = parkedMaxSetting, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd }) {
-	const root = settingsContext.projectPath;
-	const [shapeError, ...moreShapeErrors] = [parkedLimit("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)) warn("setting", `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 = resolveCompilerCache({
-		root,
-		optimizations,
-		settingsContext
-	});
-	const cas = compilerCache.cas;
-	optimizations = compilerCache.optimizations;
-	if (compilerCache.warning) warn("cache", compilerCache.warning);
-	const buildProfile = optimizationBuildProfile("android", optimizations);
-	const cacheProviderConfig = resolveCacheProvider(settingsContext);
-	const cacheProviderError = cacheProviderSettingError(settings);
-	if (cacheProviderError) warn("cache", `${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 = validateAvdConfig(settings, root);
-	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 systemImage = resolveSystemImage(systemImageFlag, settings);
-	const deviceProfile = resolveDeviceProfile(deviceProfileFlag, settings);
-	const variant = easProfile !== void 0 ? "debug" : resolveVariant(variantFlag, settings);
-	const flavorRefusal = productFlavorRefusal({
-		flavors: readFlavors(root),
-		variant
-	});
-	if (flavorRefusal) return fail(flavorRefusal.code, flavorRefusal.reason, flavorRefusal.remedy);
-	const release = isReleaseVariant(variant);
-	const cachePolicy = artifactCachePolicy(optimizations, requestedBuildCache, release);
-	const isExpo = detectExpo(root);
-	const physical = isPhysicalDeviceRequest(deviceFlag);
-	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;
-	if (waitConflict) return fail("STIM_BAD_ARG", "--wait and --no-wait ask for opposite things.", "Pass only one of `--wait <seconds>` and `--no-wait`.");
-	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 busy lease or device slot at once.");
-	const waitSeconds = waitParsed.seconds;
-	const remoteTarget = commandRemoteBackend !== null ? parseIosRemote(commandRemoteBackend) : remoteAndroidSetting(settings);
-	if (physical && remoteTarget?.kind === "machine") return fail("STIM_BAD_ARG", "--device installs on a phone connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote; unset android.remote for a local phone.");
-	const machine = remoteTarget?.kind === "machine" ? remoteTarget.machine : null;
-	const remoteBackend = !physical && remoteTarget?.kind === "backend" ? remoteTarget.backend : null;
-	if (!machine) {
-		const refusal = androidDeviceSelectorRefusal({
-			settingsContext,
-			slot,
-			systemImageFlag,
-			deviceProfileFlag,
-			systemImage,
-			deviceProfile,
-			physical,
-			remoteBackend
-		}, {
-			listSystemImages,
-			listDeviceProfiles,
-			supportsFold,
-			ownedAvd
-		});
-		if (refusal) return refusal;
-	}
-	const target = physical ? {
-		kind: "physical",
-		serial: typeof deviceFlag === "string" ? deviceFlag : null,
-		lease: {
-			waitSeconds,
-			noWait
-		}
-	} : machine ? {
-		kind: "hosted",
-		machine,
-		systemImage,
-		deviceProfile
-	} : remoteBackend ? {
-		kind: "remote",
-		backend: remoteBackend,
-		systemImage,
-		deviceProfile
-	} : {
-		kind: "emulator",
-		systemImage,
-		deviceProfile
-	};
-	return {
-		ok: true,
-		plan: {
-			build: {
-				variant,
-				release,
-				profile: buildProfile,
-				cas,
-				cache: cachePolicy,
-				compilerCache: optimizations.android.compilerCache,
-				gradleBuildCache: optimizations.android.gradleBuildCache,
-				pch: optimizations.android.pch,
-				targetAbiOnly: optimizations.android.targetAbiOnly
-			},
-			target,
-			deviceSlotWaitMs: noWait ? 0 : waitFlag === void 0 && !physical ? DEFAULT_DEVICE_SLOT_WAIT_MS : waitSeconds * 1e3,
-			isExpo,
-			metroWarmup: optimizations.metroWarmup,
-			cacheProviderConfig
-		}
-	};
-}
-function androidDeviceSelectorRefusal({ settingsContext, slot, systemImageFlag, deviceProfileFlag, systemImage, deviceProfile, physical, remoteBackend }, { listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfiles, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd } = {}) {
-	const root = settingsContext.projectPath;
-	const settingsLayersForOrigin = settingsLayers(settingsContext);
-	const imageRefusal = systemImageRefusal({
-		slot,
-		flag: systemImageFlag,
-		resolved: systemImage,
-		origin: settingOriginScope(settingsLayersForOrigin, "android.systemImage"),
-		physical,
-		remoteBackend,
-		listImages: listSystemImages
-	});
-	if (imageRefusal) return fail(imageRefusal.code, imageRefusal.message, imageRefusal.remedy);
-	const profileRefusal = deviceProfileRefusal({
-		flag: deviceProfileFlag,
-		resolved: deviceProfile,
-		origin: settingOriginScope(settingsLayersForOrigin, "android.deviceProfile"),
-		physical,
-		remoteBackend,
-		listProfiles: listDeviceProfiles
-	});
-	if (profileRefusal) return fail(profileRefusal.code, profileRefusal.message, profileRefusal.remedy);
-	const avdFlagRefusal = remoteAvdFlagRefusal({
-		systemImageFlag,
-		deviceProfileFlag,
-		remoteBackend
-	});
-	if (avdFlagRefusal) return fail(avdFlagRefusal.code, avdFlagRefusal.message, avdFlagRefusal.remedy);
-	if (!physical && !remoteBackend) {
-		const flagImage = typeof systemImageFlag === "string" && systemImageFlag.trim() ? systemImageFlag.trim() : null;
-		const existing = ownedAvd(root, slot);
-		const profile = deviceProfile ?? existing?.deviceProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
-		const image = () => flagImage ?? existing?.systemImage ?? systemImage ?? pickDefaultSystemImage(listSystemImages())?.pkg ?? null;
-		const checked = profileNeedsFoldFeature(profile) ? image() : null;
-		const foldRefusal = checked !== null && foldableImageRefusal({
-			profile,
-			image: checked,
-			avdName: existing && existing.systemImage === checked && existing.deviceProfile === profile ? existing.avdName : null,
-			images: listSystemImages,
-			supportsFold
-		});
-		if (foldRefusal) return fail(foldRefusal.code, foldRefusal.message, foldRefusal.remedy);
-	}
-	return null;
-}
-//#endregion
-//#region src/commands/android/next-build.ts
-const DEFAULT_PLAN_DEPS = {
-	findRoot: findProjectRoot,
-	fingerprint: fingerprintProject,
-	listSystemImages: listInstalledSystemImages,
-	avdSystemImage: ownedAvdSystemImage,
-	avdDirectory: ownedAvdDirectory,
-	listAvds,
-	loadCacheProvider,
-	loadProjectProvider,
-	checkEasAuth,
-	resolveRemote,
-	planPrebuild
-};
-function note(line) {
-	console.error(line);
-}
-function runOnlyFlag(opts) {
-	if (isPhysicalDeviceRequest(opts.device)) return "--device";
-	if (opts.remote) return "--remote";
-	if (opts.wait !== void 0) return opts.wait === false ? "--no-wait" : "--wait";
-	if (opts.metroCheck === false) return "--no-metro-check";
-	return null;
-}
-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 planAndroid(opts, overrides = {}) {
-	const deps = {
-		...DEFAULT_PLAN_DEPS,
-		...overrides
-	};
-	const json = Boolean(opts.json);
-	const refuse = (refusal, lines = []) => refusePlan(refusal, json, lines);
-	const flag = runOnlyFlag(opts);
-	if (flag) return refuse(planFlagRefusal(flag));
-	const root = deps.findRoot(process.cwd());
-	if (!root) return refuse(NO_PROJECT_REFUSAL);
-	const problem = projectProblem(root, "android");
-	if (problem) return refuse({
-		code: "STIM_NO_PROJECT",
-		...problem
-	});
-	const slot = validateDeviceSlot(opts.slot);
-	const settingsContext = {
-		projectPath: root,
-		gitCommonDir: gitCommonDir(root),
-		repoRoot: repoRoot(root)
-	};
-	const settings = resolveSettings(settingsContext);
-	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
-	}, {
-		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$1({
-			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 printPlan(planPayload(planTarget, {
-			fingerprint: eas.fingerprint,
-			cacheKey: eas.cacheKey,
-			cacheHit: eas.buildId ? "remote" : false,
-			provider: "eas",
-			cacheSkipped: false,
-			prebuild: null,
-			refusal: eas.missing
-		}), json);
-	}
-	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,
-		buildProfile: build.profile,
-		targetAbiOnly: build.targetAbiOnly,
-		hostedAbi
-	});
-	let fingerprint;
-	try {
-		fingerprint = await deps.fingerprint(root, { platform: PLATFORM });
-	} 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
-	});
-	printPlan(placement ? {
-		...plan,
-		placement
-	} : plan, json);
-}
-//#endregion
-//#region src/commands/android.ts
-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. A Debug run starts the dev server when it is not running.").option("--eas-profile <name>", "Download a matching EAS development build; on a miss, print the build command without running it").option("--slot <name>", "Reusable device slot within this workspace (default: default)", parseDeviceSlotOption).option("--remote-build <value>", "Build on auto, local, or one named machine; a name refuses without fallback", parseBuildMachineOption).option("--json", "Emit the facts as a single JSON line on stdout; every other line goes to stderr").option("--plan", "Predict the next build without building, booting or installing: resolve the fingerprint, check the local then remote cache, and print the expected cache result and duration. Writes no Stim state.").option("--no-metro-check", "Skip the reserved-port Metro health check and do not start it (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-profile <id>", "Hardware profile to create this workspace's owned AVD with, as an `avdmanager list device -c` id (e.g. \"pixel_fold\", \"pixel_tablet\"). Overrides the android.deviceProfile setting for this invocation. An unknown id refuses with STIM_BAD_ARG and prints the available ids.").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 <target>", "Run on eas, proxy, or a named approved Mac from remote.machines; auto places on an approved Mac when this Mac is full or busy; local runs here, whatever android.remote says", (value) => {
-		if (!parseMachine(value)) throw new InvalidArgumentError("expected eas, proxy, auto, local, or a tailnet machine name");
-		return value;
-	}).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). Without --device, wait for an owned-device slot (default 600 seconds; --no-wait refuses immediately).").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. Without --device, refuse a full device cap or existing slot queue immediately.").action(async (opts) => {
-		if (opts.plan) return planAndroid(opts);
-		const root = findProjectRoot(process.cwd());
-		if (!root) {
-			refuseNoProject({ json: Boolean(opts.json) });
-			return;
-		}
-		if (!(await runAndroidOperation(root, {
-			...opts,
-			waitConflict: waitFlagConflict(process.argv)
-		})).ok) process.exit(runCancellation() ? 130 : 1);
-	});
-}
-function runAndroidOperation(root, opts = {}) {
-	return withNativeBuildRun(root, {
-		command: "android",
-		platform: PLATFORM,
-		slot: opts.slot ?? "default"
-	}, async (claim) => {
-		recordWorkspaceUse(root);
-		const progress = startBuildProgress({
-			root,
-			platform: PLATFORM,
-			slot: opts.slot ?? "default",
-			claim,
-			note: (line) => console.error(chalk.dim(line))
-		});
-		try {
-			return await runAndroid({
-				root,
-				buildMachine: opts.remoteBuild,
-				slot: opts.slot,
-				easProfile: opts.easProfile,
-				json: Boolean(opts.json),
-				metroCheck: opts.metroCheck !== false,
-				useBuildCache: opts.buildCache !== false,
-				variant: opts.variant ?? null,
-				systemImage: opts.systemImage ?? null,
-				deviceProfile: opts.deviceProfile ?? null,
-				remoteDevice: opts.remote ?? null,
-				device: opts.device ?? null,
-				wait: opts.wait,
-				waitConflict: opts.waitConflict,
-				progress
-			});
-		} finally {
-			progress.clear();
-		}
-	}, { write: (line) => console.error(chalk.dim(phaseLine("lock", line))) });
-}
-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, easProfile, resolveEasDevelopmentBuild: resolveEasBuild = resolveEasDevelopmentBuild, variant: variantFlag = null, systemImage: systemImageFlag = null, deviceProfile: deviceProfileFlag, 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, listDeviceProfiles, ensureDeviceBooted = ensureBooted, resolveAvdSerial = resolveOwnedAvdSerial, waitForDeviceBoot = waitForBoot, dataFreeBytes, trimCaches, wipeDevice, resolveMetro = resolveProjectMetro, warmMetro: prewarmMetro = warmMetro, startServer = startDevServer, readState = readWorkspaceState$1, 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, planPrebuildFor = planPrebuild, 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, recordBuild, recordStats = recordRunStats, recordCapacityRefusal: recordRefusal, 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,
-		easProfile,
-		resolveEasBuild,
-		variantFlag,
-		systemImageFlag,
-		deviceProfileFlag,
-		deviceFlag,
-		waitFlag,
-		waitConflict,
-		acquireLease,
-		makeRunLease,
-		selectPool,
-		onLeaseSignal,
-		listDevices,
-		deviceModel,
-		deviceAbi,
-		isEmulatorDevice,
-		readApkPackage,
-		getLimits,
-		checkCapacity,
-		acquireSlot,
-		releaseSlot,
-		ensureDevice,
-		listSystemImages,
-		listDeviceProfiles,
-		ensureDeviceBooted,
-		resolveAvdSerial,
-		waitForDeviceBoot,
-		dataFreeBytes,
-		trimCaches,
-		wipeDevice,
-		resolveMetro,
-		prewarmMetro,
-		startServer,
-		readState,
-		pidAlive,
-		verifyCollector,
-		verifyLaunched,
-		ensureStorage,
-		fingerprint,
-		untracked,
-		resolveCached,
-		storeCached,
-		storedAssets,
-		captureAssets,
-		acquireLock,
-		releaseLock,
-		waitForBuild: waitForBuild$1,
-		loadProvider,
-		easAuth,
-		resolveRemoteBuild,
-		uploadRemoteBuild,
-		resolveCacheProvider,
-		loadCacheProviderModule,
-		planPrebuildFor,
-		prebuild,
-		build,
-		ccacheFor,
-		install,
-		launch,
-		launchRelease,
-		verifyReleaseLaunched,
-		swapApk,
-		resolveDevClientScheme,
-		spawn,
-		kill,
-		createWriter,
-		writeLaunch,
-		writeState,
-		recordBuild,
-		recordStats,
-		recordCapacityRefusal: recordRefusal,
-		readEstimates,
-		now,
-		out,
-		emit
-	};
-}
-function androidSlotOptions(options) {
-	const base = resolveRunAndroidOptions(options);
-	const slot = validateDeviceSlot(options.slot);
-	if (slot === "default") return base;
-	return {
-		...base,
-		ensureDevice: (args) => base.ensureDevice({
-			...args,
-			slot
-		}),
-		ensureDeviceBooted: (args) => base.ensureDeviceBooted({
-			...args,
-			slot
-		}),
-		checkCapacity: (args) => base.checkCapacity({
-			...args,
-			slot
-		}),
-		selectPool: (args) => base.selectPool({
-			...args,
-			slot
-		}),
-		acquireLease: (args) => base.acquireLease({
-			...args,
-			slot
-		}),
-		makeRunLease: (args) => base.makeRunLease({
-			...args,
-			slot
-		}),
-		writeLaunch: ((projectRoot, platform, record) => base.writeLaunch(projectRoot, platform, record, slot))
-	};
-}
-function avdSetupFailure(error, root, logFile) {
-	const refusal = (0, ownership_claim_exports.claimFailure)(error, "stim android");
-	if (refusal) return refusal;
-	if (error instanceof DeviceAdmissionRefusal) return {
-		code: error.code,
-		message: error.message,
-		remedy: error.remedy
-	};
-	const diag = noDeviceDiagnostic({
-		reason: `Could not ensure an owned Android emulator: ${error?.message || error}`,
-		logFile,
-		localEmulator: !(error instanceof AvdRecoveryError),
-		remedy: error instanceof AvdBootError ? error.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 {
-		code: NO_DEVICE,
-		message: diag.message,
-		remedy: diag.remedy,
-		extra: {
-			lines: diag.lines,
-			logPath: diag.logPath ? displayPath(root, diag.logPath) : null
-		}
-	};
-}
-async function runAndroid(options = {}) {
-	let { root, json, commandRemoteBackend, resolveSettingsFor, resolveRemoteDeviceContext, makeRemoteDeviceDeps, resolveEasBin, ensureRemoteMetro, ensureRemoteOwned, detectRemoteProviders, metroCheck, useBuildCache: requestedBuildCache, easProfile, resolveEasBuild, variantFlag, systemImageFlag, deviceProfileFlag, deviceFlag, waitFlag, waitConflict, acquireLease, makeRunLease, selectPool, onLeaseSignal, listDevices, deviceModel, deviceAbi, isEmulatorDevice, readApkPackage, getLimits, checkCapacity, acquireSlot, releaseSlot, ensureDevice, listSystemImages, listDeviceProfiles, ensureDeviceBooted, resolveAvdSerial, waitForDeviceBoot, dataFreeBytes, trimCaches, wipeDevice, resolveMetro, prewarmMetro, startServer, readState, pidAlive, verifyCollector, verifyLaunched, ensureStorage, fingerprint, untracked, resolveCached, storeCached, storedAssets, captureAssets, acquireLock, releaseLock, waitForBuild, loadProvider, easAuth, resolveRemoteBuild, uploadRemoteBuild, resolveCacheProvider, loadCacheProviderModule, planPrebuildFor, prebuild, build, ccacheFor, install, launch, launchRelease, verifyReleaseLaunched, swapApk, resolveDevClientScheme, spawn, kill, createWriter, writeLaunch, writeState, recordBuild, recordStats, recordCapacityRefusal: recordRefusal = recordCapacityRefusal, readEstimates, now, out, emit } = androidSlotOptions(options);
-	const progress = options.progress ?? NO_BUILD_PROGRESS;
-	const slot = validateDeviceSlot(options.slot);
-	const started = now();
-	const startedAt = new Date(started).toISOString();
-	const problem = projectProblem(root, "android");
-	if (problem) {
-		const { message, remedy } = problem;
-		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$1(root);
-	const buildLog = join(logsDir, `build-${deviceSlotFileKey("android", slot)}.ndjson`);
-	const writer = tapBuildLog(createWriter(buildLog, {
-		truncate: true,
-		fields: {
-			platform: PLATFORM,
-			slot
-		}
-	}), progress);
-	setRemoteLogSink((entry) => writer.write(entry));
-	const record = {
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		appPath: null,
-		bundleId: null,
-		avdName: null,
-		deviceName: null
-	};
-	const phase = (label, text) => out(phaseLine(label, text));
-	const stats = createRunRecorder({
-		platform: PLATFORM,
-		write: recordStats,
-		now,
-		note: (line) => out(phaseLine("stats", chalk.dim(line))),
-		phases: () => progress.durations(),
-		deviceSetup: () => progress.deviceSetupKnown()
-	});
-	const recordRun = stats.record;
-	let ccacheActivity = CCACHE_NOT_RUN;
-	let reclaimed = [];
-	const fail = (code, message, remedy, { lastBuildStatus = false, setup = false, diagnostics = [], buildDiagnostics: rawDiagnostics = [], lines = [], logPath = null, lease } = {}) => {
-		const cancellation = cancelledFailure(PLATFORM, {
-			code,
-			message
-		});
-		if (cancellation) ({code, message, remedy, lines} = cancellation);
-		if (lastBuildStatus) persistLastBuild({
-			recordBuild,
-			root,
-			record,
-			startedAt,
-			durationMs: now() - started,
-			status: "failed",
-			errorCode: code,
-			diagnostics: rawDiagnostics,
-			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));
-		if (!setup) recordRun({
-			failed: true,
-			durationMs: now() - started
-		});
-		if (json) emit(JSON.stringify({
-			code,
-			message,
-			remedy: remedy ?? null,
-			...record.devicePlacement ? { devicePlacement: record.devicePlacement } : {},
-			...ccacheActivity.status === "not-run" ? {} : { ccache: ccacheActivity },
-			...lease === void 0 ? {} : { lease },
-			...reclaimed.length ? { reclaimed } : {}
-		}));
-		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$1({
-		root,
-		commonDir: settingsContext.gitCommonDir,
-		repoRoot: settingsRepoRoot
-	});
-	stats.setProject(projectKey);
-	progress.estimate(projectKey);
-	let estimatesRead = null;
-	const estimates = () => estimatesRead ??= readEstimates({
-		projectKey,
-		platform: PLATFORM
-	});
-	const settings = resolveSettingsFor(settingsContext);
-	const placement = resolveBuildPlacement(options.buildMachine);
-	record.buildMachine = placement.selected;
-	if (placement.failure) {
-		const { code, message, remedy } = placement.failure;
-		return fail(code, message, remedy, { setup: true });
-	}
-	const planned = resolveAndroidRunPlan({
-		settings,
-		settingsContext,
-		slot,
-		easProfile,
-		variant: variantFlag,
-		systemImage: systemImageFlag,
-		deviceProfile: deviceProfileFlag,
-		device: deviceFlag,
-		wait: waitFlag,
-		waitConflict,
-		remote: commandRemoteBackend,
-		buildCache: requestedBuildCache
-	}, {
-		resolveCacheProvider,
-		listSystemImages,
-		listDeviceProfiles,
-		warn: (label, message) => out(phaseLine(label, chalk.yellow(message)))
-	});
-	if (!planned.ok) return fail(planned.code, planned.message, planned.remedy, { lines: planned.lines });
-	const { plan } = planned;
-	const deviceSlotWait = {
-		automatic: plan.target.kind === "hosted" && plan.target.machine === "auto",
-		signal: runCancellationSignal(),
-		waitMs: plan.deviceSlotWaitMs,
-		displayName: basename(root),
-		waitingFor: (info) => progress.waitingFor(info, "device-slot"),
-		onWait: (ms) => {
-			stats.addDeviceSlotWaitMs(ms);
-			if (record.devicePlacement?.decision === "local" && ms > 0) record.devicePlacement.decision = "waited-locally";
-		}
-	};
-	const { build: buildPlan, isExpo, cacheProviderConfig } = plan;
-	const { variant, release, cache: cachePolicy } = buildPlan;
-	record.configuration = variant ?? "debug";
-	const useBuildCache = cachePolicy.read;
-	const hosting = await selectAndroidPlacement({
-		root,
-		slot,
-		target: plan.target,
-		release,
-		metroCheck,
-		noWait: plan.deviceSlotWaitMs === 0,
-		buildMachine: options.buildMachine,
-		read: options.readHostedAndroid,
-		resolveSerial: resolveAvdSerial,
-		prepare: options.prepareHostedAndroid,
-		automatic: options.automaticDevicePlacement,
-		...remoteEasFallbackSetting(settings) ? { eas: () => (options.checkEasFallback ?? checkEasFallback)({
-			root,
-			platform: PLATFORM,
-			slot,
-			release,
-			isExpo,
-			tunnelMode: tunnelModeSetting(settings),
-			publicUrl: publicUrlSetting(settings),
-			localOnlyFlags: [...typeof systemImageFlag === "string" ? ["--system-image"] : [], ...typeof deviceProfileFlag === "string" ? ["--device-profile"] : []]
-		}) } : {},
-		localSelectors: (target) => androidDeviceSelectorRefusal({
-			settingsContext,
-			slot,
-			systemImageFlag,
-			deviceProfileFlag,
-			systemImage: target.systemImage,
-			deviceProfile: target.deviceProfile,
-			physical: false,
-			remoteBackend: null
-		}, {
-			listSystemImages,
-			listDeviceProfiles
-		}),
-		checkBudget: options.checkBudget,
-		note: out,
-		phase,
-		log: (entry) => writer.write(entry),
-		fromFlag: commandRemoteBackend !== null
-	});
-	if ("failure" in hosting) return fail(hosting.failure.code, hosting.failure.message, hosting.failure.remedy);
-	const { target, hostedTarget, budget, selectors } = hosting;
-	record.devicePlacement = hosting.devicePlacement;
-	writeDevicePlacement(root, slot, PLATFORM, record.devicePlacement);
-	const physical = target.kind === "physical";
-	const remoteBackend = target.kind === "remote" ? target.backend : null;
-	if (hostedTarget) {
-		if (settings.androidEmulatorApp !== void 0) phase("device", "androidEmulatorApp is ignored on a hosting Mac; the emulator boots headless.");
-		if (publicUrlSetting(settings) || tunnelModeSetting(settings)) phase("metro", "metro.publicUrl and metro.tunnel are ignored on a hosting Mac; Metro uses the private tailnet bridge.");
-	}
-	reclaimed = budget.reclaimed;
-	if (budget.refusal) return fail(budget.refusal.code, budget.refusal.message, budget.refusal.remedy);
-	const remoteContext = remoteBackend ? await resolveRemoteDeviceContext({
-		root,
-		platform: PLATFORM,
-		backend: remoteBackend,
-		easBin: resolveEasBin(root)?.file ?? null
-	}) : null;
-	if (remoteContext && "failed" in remoteContext) return fail(remoteContext.code ?? "STIM_NO_REMOTE_SESSION", remoteContext.failed, remoteContext.remedy);
-	const easBuild = await resolveEasBuild({
-		root,
-		platform: PLATFORM,
-		profile: easProfile,
-		note: out,
-		isExpo,
-		physical,
-		selectors: [variantFlag],
-		buildCache: requestedBuildCache
-	});
-	if (isEasBuildFailure(easBuild)) return fail(easBuild.code, easBuild.message, easBuild.remedy);
-	const appIds = detectAppIds(root);
-	let androidPackage = appIds.androidPackage;
-	record.bundleId = androidPackage;
-	const registerProject = () => upsertProject(root, {
-		bundleId: appIds.bundleId ?? 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 devServer = null;
-	async function prepareMetro() {
-		if (metroCheck) {
-			const gate = await ensureDevServer({
-				root,
-				port: reservedPort,
-				settings: hostedMetroSettings(settings, Boolean(hostedTarget)),
-				remote: remoteContext !== null,
-				note: out,
-				resolve: resolveMetro,
-				start: startServer,
-				readState
-			});
-			reclaimed = [...reclaimed, ...gate.reclaimed];
-			if (!gate.ok) return {
-				ok: false,
-				error: {
-					code: gate.code,
-					message: gate.message,
-					remedy: gate.remedy,
-					lines: gate.lines
-				}
-			};
-			metroPort = gate.port;
-			devServer = gate.devServer;
-			phase("metro", `port ${metroPort} (${devServer ? `started: ${devServer.reason}` : `pid ${gate.pid ?? "unknown, started outside Stim"}`})`);
-			return {
-				ok: true,
-				prepared: { metroPort }
-			};
-		} else {
-			const pin = metroPortSetting(root);
-			if (pin.error) return {
-				ok: false,
-				error: {
-					code: "STIM_BAD_ARG",
-					message: pin.error,
-					remedy: SETTING_SHAPE_REMEDY
-				}
-			};
-			metroPort = pin.port ?? reservedPort ?? 8081;
-			phase("metro", pin.port ?? reservedPort ? `port ${metroPort} (not checked)` : `no reservation; using ${DEFAULT_METRO_PORT} (not checked)`);
-		}
-		return {
-			ok: true,
-			prepared: { metroPort }
-		};
-	}
-	const runtime = options.runtimePlan ?? (release ? androidProcessRuntime(async () => {
-		phase("metro", `skipped (${variant}: the JS bundle is embedded, no dev server is used)`);
-		return {
-			ok: true,
-			prepared: { metroPort: null }
-		};
-	}) : androidMetroRuntime(prepareMetro));
-	const preparation = await runtime.prepare();
-	if (!preparation.ok) {
-		const { code, message, remedy, lines } = preparation.error;
-		return fail(code, message, remedy, { lines });
-	}
-	const runtimePreparation = preparation.prepared;
-	metroPort = runtimePreparation.metroPort;
-	if (remoteContext) {
-		remoteDevice = makeRemoteDeviceDeps(remoteContext.ctx);
-		if (metroPort !== null) {
-			const reachable = await ensureRemoteMetro({
-				ctx: remoteDevice.ctx,
-				metroPort,
-				isExpo,
-				tunnelMode: tunnelModeSetting(settings) ?? void 0,
-				publicUrl: publicUrlSetting(settings),
-				available: detectRemoteProviders(binOnPath, tunnelModeSetting(settings) ?? "auto")
-			});
-			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;
-	let startRemoteBoot = null;
-	if (hostedTarget) {
-		device = {
-			owned: false,
-			systemImage: hostedTarget.choice.systemImage,
-			deviceProfile: hostedTarget.choice.deviceProfile
-		};
-		bootPromise = Promise.resolve({ ok: true });
-	} else if (target.kind === "physical" && !target.serial) {
-		const pooled = await pooledAndroidDevice({
-			root,
-			selectPool,
-			listDevices,
-			isEmulatorDevice,
-			deviceModel,
-			waitSeconds: target.lease.waitSeconds,
-			noWait: target.lease.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 (target.kind === "physical") {
-		const resolved = resolvePhysicalDevice(target.serial, 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 {
-		if (!remoteDevice) try {
-			configuredAndroidEmulatorApp();
-		} catch (err) {
-			return fail("STIM_BAD_ARG", err.message, "Run `stim settings set androidEmulatorApp emulator` or `stim settings set androidEmulatorApp stim-desktop`.");
-		}
-		const capacity = plan.deviceSlotWaitMs === 0 ? checkCapacity({
-			platform: PLATFORM,
-			project,
-			max: limits.maxDevices
-		}) : null;
-		if (capacity) {
-			if (capacity.code === "STIM_AT_CAPACITY") recordRefusal({
-				platform: PLATFORM,
-				max: limits.maxDevices,
-				workspace: workspaceId(root)
-			}, now());
-			return fail(capacity.code, capacity.message, capacity.remedy);
-		}
-		const prepare = stepClock(now);
-		try {
-			device = await ensureDevice({
-				platform: PLATFORM,
-				project,
-				projectPath: root,
-				settingsRoot,
-				settings,
-				flags: {
-					deviceSlotWait,
-					systemImage: target.systemImage,
-					systemImageFlag: systemImageFlag?.trim() || null,
-					deviceProfile: target.deviceProfile
-				},
-				note: out,
-				out,
-				logFile: emuLog
-			});
-		} catch (err) {
-			const failure = avdSetupFailure(err, root, emuLog);
-			return fail(failure.code, failure.message, failure.remedy, failure.extra);
-		}
-		progress.deviceSetup(didSetUpDevice(device, Boolean(remoteDevice)));
-		const prepareMs = prepare();
-		if (device.created || prepareMs >= 2e3) phase("device", `${device.avdName || device.deviceName || label} ${device.created ? "created" : "prepared"} (${formatDuration(prepareMs)})`);
-		const boot = () => Promise.resolve(ensureDeviceBooted({
-			platform: PLATFORM,
-			device,
-			projectPath: root,
-			deviceSlotWait,
-			out,
-			logFile: emuLog
-		})).catch((e) => ({
-			failed: true,
-			reason: String(e?.message || e),
-			serial: void 0
-		}));
-		const startBoot = () => {
-			const bootTimer = stepTimer(now);
-			return (remoteDevice?.ctx.backend === "eas" ? ensureRemoteOwned({
-				root,
-				platform: PLATFORM,
-				sessionName: ownedSessionName(remoteDevice.ctx.label),
-				startedAt: new Date(now()).toISOString(),
-				boot,
-				createdSessionId: remoteDevice.createdSessionId,
-				abandonCreatedSession: remoteDevice.abandonCreatedSession,
-				webPreviewUrl: remoteDevice.webPreviewUrl,
-				writeState,
-				register: registerProject,
-				notice: (line) => out(chalk.dim(phaseLine("lock", line)))
-			}) : boot()).then((result) => {
-				bootDuration = bootTimer();
-				return result;
-			});
-		};
-		if (remoteDevice) startRemoteBoot = startBoot;
-		else bootPromise = startBoot();
-	}
-	record.avdName = device.avdName ?? null;
-	record.deviceName = device.deviceName ?? device.avdName ?? null;
-	record.systemImage = device.systemImage;
-	record.deviceProfile = device.deviceProfile;
-	const runFromFingerprint = async () => {
-		if (metroCheck && metroPort !== null && plan.metroWarmup) prewarmMetro({
-			port: metroPort,
-			platform: "android",
-			isExpo,
-			appId: androidPackage,
-			bundleUrl: metroWarmupUrlSetting(settings, "android")
-		});
-		const acquiredArtifact = await acquireAndroidArtifact({
-			root,
-			buildLog,
-			writer,
-			settings,
-			isExpo,
-			device,
-			physical,
-			hostedAbi: hostedTarget?.choice.architecture,
-			remote: Boolean(remoteDevice),
-			buildPlan,
-			cacheProviderConfig,
-			requestedBuildCache,
-			easBuild,
-			androidPackage,
-			record,
-			maxBuilds: limits.maxBuilds,
-			progress: {
-				phase,
-				out,
-				estimates,
-				stats,
-				step: progress.step,
-				miss: progress.miss,
-				hit: progress.hit,
-				place: progress.place,
-				waitingOn: progress.waitingOn,
-				waitingFor: progress.waitingFor
-			}
-		}, {
-			deviceAbi,
-			fingerprint,
-			untracked,
-			resolveCached,
-			storeCached,
-			storedAssets,
-			captureAssets,
-			acquireLock,
-			releaseLock,
-			waitForBuild,
-			loadProvider,
-			easAuth,
-			resolveRemoteBuild,
-			uploadRemoteBuild,
-			loadCacheProviderModule,
-			acquireSlot,
-			releaseSlot,
-			planPrebuildFor,
-			prebuild,
-			build,
-			ccacheFor,
-			swapApk,
-			readState,
-			now
-		});
-		if (!acquiredArtifact.ok) {
-			ccacheActivity = acquiredArtifact.ccache;
-			const { failure } = acquiredArtifact;
-			return fail(failure.code, failure.message, failure.remedy, failure.extra);
-		}
-		const { artifact } = acquiredArtifact;
-		const { apkPath } = artifact;
-		ccacheActivity = artifact.ccache;
-		androidPackage = artifact.androidPackage;
-		record.appPath = apkPath;
-		if (runCancellation()) return fail("STIM_CANCELLED", "before install");
-		if (hostedTarget) return finishHostedAndroidRun({
-			target: hostedTarget,
-			artifact,
-			root,
-			slot,
-			release,
-			isExpo,
-			metroPort,
-			logsDir,
-			selectors,
-			place: options.placeHostedAndroid ?? placeHostedAndroid,
-			writePlacement: options.writeHostedAndroid ?? writeHostedAndroid,
-			verifyLaunch: verifyLaunched,
-			writeLaunch,
-			readApkPackage,
-			resolveDevClientScheme,
-			now,
-			started,
-			startedAt,
-			record,
-			fail,
-			phase,
-			enterPhase: progress.step,
-			out,
-			json,
-			useBuildCache,
-			variant,
-			metroCheck,
-			writer,
-			emit,
-			recordRun,
-			reclaimed,
-			devServer,
-			recordBuild
-		});
-		if (startRemoteBoot) {
-			progress.step("device");
-			bootPromise = startRemoteBoot();
-			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
-				});
-			}
-		}
-		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) {
-			progress.step("device");
-			const acquired = await acquireLease({
-				root,
-				platform: PLATFORM,
-				id: device.serial,
-				deviceName: device.deviceName ?? null,
-				idLabel: "serial",
-				waitSeconds: target.lease.waitSeconds,
-				noWait: target.lease.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({
-				runtime,
-				runtimePreparation,
-				slot,
-				lease: leaseHandle,
-				releaseLease,
-				root,
-				json,
-				metroCheck,
-				useBuildCache,
-				variant,
-				release,
-				isExpo,
-				metroPort,
-				logsDir,
-				emuLog,
-				device,
-				physical,
-				remoteDevice,
-				bootPromise,
-				resolveAvdSerial,
-				waitForDeviceBoot,
-				dataFreeBytes,
-				trimCaches,
-				wipeDevice,
-				bootDuration: () => bootDuration,
-				apkPath,
-				androidPackage,
-				swapDir: artifact.swapDir,
-				record,
-				waitedForBuild: artifact.waitedForBuild,
-				ccache: ccacheActivity,
-				uploadPending: artifact.uploadPending,
-				providerUpload: artifact.providerUpload,
-				providerName: artifact.providerName,
-				remote: artifact.remote,
-				abandonedRemote: artifact.abandonedRemote,
-				started,
-				startedAt,
-				writer,
-				phase,
-				fail,
-				readApkPackage,
-				install,
-				launch,
-				launchRelease,
-				resolveDevClientScheme,
-				verifyLaunched,
-				verifyReleaseLaunched,
-				spawn,
-				kill,
-				pidAlive,
-				verifyCollector,
-				writeLaunch,
-				recordBuild,
-				now,
-				out,
-				emit,
-				recordRun,
-				reclaimed,
-				devServer,
-				enterPhase: progress.step,
-				rebootDevice: () => Promise.resolve(ensureDeviceBooted({
-					platform: PLATFORM,
-					device: {
-						...device,
-						serial: void 0
-					},
-					projectPath: root,
-					deviceSlotWait,
-					out,
-					logFile: emuLog
-				})).catch((e) => ({
-					failed: true,
-					reason: String(e?.message || e)
-				}))
-			});
-		} finally {
-			releaseLease();
-		}
-	};
-	try {
-		return await runFromFingerprint();
-	} catch (error) {
-		recordRun({
-			failed: true,
-			durationMs: now() - started
-		});
-		throw error;
-	}
-}
-//#endregion
-export { collectorLogFile as a, androidFacts as c, runAndroidOperation as i, lastBuildRecord as l, registerAndroid as n, killPreviousCollector as o, runAndroid as r, startCollector as s, androidCommand as t };