stim 1.19.0 → 1.20.1

package/dist/android-CLbBJ2ve.mjs

@@ -0,0 +1,1258 @@
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { E as upsertProject, L as deviceSlotFileKey, V as parseDeviceSlotOption, W as validateDeviceSlot, p as getProject, u as getConcurrencyLimits, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { I as projectSettingsContext, K as resolveProjectSettings, L as publicUrlSetting, N as metroWarmupUrlSetting, V as remoteEasFallbackSetting, W as resolveCacheProviderConfig, a as SETTING_SHAPE_REMEDY, at as detectProviders, g as deviceReclaimIdleMinutesSetting, j as metroPortSetting, q as resolveSettings, tt as tunnelModeSetting } from "./settings-Bbztm4oV.mjs";
+import { _ as waitForBuild, g as releaseBuildLock, m as acquireBuildLock } from "./device-lease-C309csaB.mjs";
+import { c as writeWorkspaceState, f as emulatorLogFile, i as recordWorkspaceUse, r as readWorkspaceState$1, w as workspaceLogsDir$1 } from "./workspace-state-CvgTFe-h.mjs";
+import { _ as stepTimer, f as refuseNoProject, g as stepClock, i as formatDuration, l as phaseLine } from "./command-output-CPDq_90S.mjs";
+import { I as workspaceDevServerMode, R as writeWorkspaceLaunch, c as projectShortcut, d as projectRegistry, r as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-DX8fXyw_.mjs";
+import { G as probeEmulatorSerial, J as resolveOwnedAvdSerial, O as listAdbDevices, U as physicalDeviceModel, Y as resolvePhysicalDevice, a as androidDeviceAbi, ht as configuredAndroidEmulatorApp, j as listInstalledSystemImages, tt as waitForBoot } from "./android-DE8-JfGW.mjs";
+import { s as pidExists, u as resolveProjectMetro } from "./metro-_ZIE3Axg.mjs";
+import { F as acquireBuildSlot, L as releaseBuildSlot } from "./workspaces-C4kqIOlx.mjs";
+import { At as createRunRecorder, Ft as recordRunStats, It as statsProjectKey$1, Nt as recordCapacityRefusal, Ot as startBuildProgress, jt as readRunEstimates, kt as tapBuildLog, t as budgetGate, yt as NO_BUILD_PROGRESS } from "./budget-RFbwFpG5.mjs";
+import { S as withNativeBuildRun, b as runCancellation, p as cancelledFailure, x as runCancellationSignal } from "./tailnet-D7-tE_ug.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { f as resolveEasCliBin, i as checkEasAuth, m as uploadRemote, p as resolveRemote } from "./remote-cache-fxcl5C-L.mjs";
+import { f as setRemoteLogSink, g as parseBuildMachineOption, y as resolveBuildPlacement } from "./client-zqjFd79D.mjs";
+import { c as startDevServer } from "./start-CRkG-mZ7.mjs";
+import { d as verifyAndroidReleaseLaunch, f as verifyLaunch } from "./launch-verify-Dl78EVgR.mjs";
+import { b as launchAndroidReleaseApp, h as installAndroidApp, r as DEFAULT_METRO_PORT, t as ADB_INSTALL_TIMEOUT_MS, y as launchAndroidApp } from "./app-install-Cg9YJy3x.mjs";
+import { n as ensureWorkspaceStorageSafely, r as isPhysicalDeviceRequest, t as ensureDevServer } from "./native-runtime-D024BAvm.mjs";
+import { n as devicePlacementRecord } from "./placement-log-BItXET1x.mjs";
+import { t as CCACHE_NOT_RUN } from "./ccache-CtbqWxIC.mjs";
+import { n as DeviceAdmissionRefusal, r as checkDeviceCapacity } from "./device-capacity-DrwHwR97.mjs";
+import { S as pooledAndroidDevice, a as PLATFORM, b as noDeviceDiagnostic, g as dumpApkManifest, h as displayPath, o as androidBuildOptions, p as apkPackage, r as NO_DEVICE, s as androidDevClientScheme } from "./support-Ca6PZbpr.mjs";
+import { r as resolveAndroidRunPlan, t as androidDeviceSelectorRefusal } from "./plan-Jwu_vr-F.mjs";
+import { t as acquireAndroidArtifact } from "./artifact-DXk_Fle_.mjs";
+import { a as acquireRunLease, d as runLease, f as waitFlagConflict, o as leaseExpiryText, u as releaseLeaseOnSignal } from "./device-lease-run-Baelt3nc.mjs";
+import { a as reportAndroidResult, i as persistLastBuild, n as finishAndroidUpload } from "./result-BrfgXtdO.mjs";
+import { r as hostedMetroSettings } from "./metro-gateway-BzlQZQmU.mjs";
+import { a as writeHostedAndroid, i as writeDevicePlacement, t as readHostedAndroid } from "./ios-state-BsXMwo5y.mjs";
+import { a as refusePlan, c as devicePlacementLine, i as printPlan, n as planFlagRefusal, o as checkEasFallback, s as automaticDevicePlacement } from "./build-plan-CRjAA6Qi.mjs";
+import { n as prepareHostedAndroid, t as placeHostedAndroid } from "./hosted-android-C-D8Dj0_.mjs";
+import { r as siblingPlatformSlots, t as launchSlotScope } from "./slot-launch-CeCRr6MK.mjs";
+import { S as ownedSessionName, a as ensureMetroReachable, c as remoteAndroidDeps, n as binOnPath, o as ensureRemoteBootOwned, u as resolveRemoteContext } from "./device-remote-DjsNw8DD.mjs";
+import { a as resolveEasDevelopmentBuild, r as isEasBuildFailure } from "./eas-build-0gadvrca.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-BrjepDiv.mjs";
+import { a as AvdRecoveryError, i as AvdBootError, n as ensureBooted, o as warmMetro, r as ensureOwnedDevice, t as didSetUpDevice } from "./device-D4DqjSZZ.mjs";
+import { t as selectFromPool } from "./device-pool-DtK9S6AD.mjs";
+import { r as finishAndroidRun } from "./launch-V1zqiOYn.mjs";
+import { t as unsupportedPlan } from "./project-plan-BPwbLwQu.mjs";
+import { basename, join } from "node:path";
+import { hostedAndroidStatus, parseMachine } from "@stim-cli/core/state";
+import { loadCacheProvider } from "@stim-cli/cache";
+import { workspaceId } from "@stim-cli/core";
+import { InvalidArgumentError } from "commander";
+import chalk from "chalk";
+//#region src/commands/android/remote.ts
+async function connectAndroidHosting({ root, slot, machine, release, appMode = release ? "release" : "development", 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 (appMode === "development" && !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, appMode === "process" ? appMode : void 0) };
+	} 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 appMode = args.appMode ?? (args.release ? "release" : "development");
+	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",
+			...appMode === "process" ? { appMode } : {},
+			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 && appMode === "development" && !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/hosted.ts
+async function finishHostedAndroidRun({ target, artifact, root, slot = "default", release, appMode = release ? "release" : "development", 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,
+			...appMode === "process" ? { mode: appMode } : {},
+			metroPort,
+			selectors,
+			...appMode === "development" && 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,
+			...appMode === "process" ? { runtime: "process" } : {},
+			launchedAt: new Date(launchedAt).toISOString()
+		}, slot);
+		let launched = run.launched;
+		if (appMode === "development") {
+			const evidence = await verify({
+				requireBundleResponse: true,
+				platform: "android",
+				logsDir: logsDir ?? void 0,
+				since: launchedAt,
+				metroPort,
+				mode: workspaceDevServerMode(root, isExpo),
+				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,
+				...appMode === "process" ? { runtimeKind: "process" } : {},
+				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.`);
+	}
+}
+//#endregion
+//#region src/commands/android/next-build.ts
+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;
+}
+async function planAndroid(opts, overrides = {}) {
+	const deps = {
+		findRoot: findProjectRoot,
+		projectRegistry,
+		...overrides
+	};
+	const json = Boolean(opts.json);
+	const flag = runOnlyFlag(opts);
+	if (flag) return refusePlan(planFlagRefusal(flag), json);
+	const root = deps.findRoot(process.cwd());
+	if (!root) return refusePlan(NO_PROJECT_REFUSAL, json);
+	const selected = deps.projectRegistry.selectAndroid(root);
+	if ("problem" in selected) return refusePlan({
+		code: "STIM_NO_PROJECT",
+		...selected.problem
+	}, json);
+	const resolved = resolveProjectSettings(root);
+	const project = await selected.load(resolved);
+	if (!project.plan) return refusePlan(unsupportedPlan("android"), json);
+	const result = await project.plan(opts, resolved);
+	if ("platform" in result) printPlan(result, json);
+	else refusePlan(result.refusal, json, result.lines);
+}
+//#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. React Native and Expo Debug runs start 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, acquireLock = acquireBuildLock, releaseLock = releaseBuildLock, waitForBuild: waitForBuild$1 = waitForBuild, easAuth = checkEasAuth, resolveRemoteBuild = resolveRemote, uploadRemoteBuild = uploadRemote, resolveCacheProvider = resolveCacheProviderConfig, loadCacheProviderModule = loadCacheProvider, install = installAndroidApp, launch = launchAndroidApp, launchRelease = launchAndroidReleaseApp, verifyReleaseLaunched = verifyAndroidReleaseLaunch, 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,
+		acquireLock,
+		releaseLock,
+		waitForBuild: waitForBuild$1,
+		easAuth,
+		resolveRemoteBuild,
+		uploadRemoteBuild,
+		resolveCacheProvider,
+		loadCacheProviderModule,
+		install,
+		launch,
+		launchRelease,
+		verifyReleaseLaunched,
+		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, acquireLock, releaseLock, waitForBuild, easAuth, resolveRemoteBuild, uploadRemoteBuild, resolveCacheProvider, loadCacheProviderModule, install, launch, launchRelease, verifyReleaseLaunched, 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 selectedProject = (options.projectRegistry ?? projectRegistry).selectAndroid(root);
+	if ("problem" in selectedProject) {
+		const { message, remedy } = selectedProject.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 settingsRoot = root;
+	const settingsContext = projectSettingsContext(root);
+	const projectKey = statsProjectKey$1({
+		root,
+		commonDir: settingsContext.gitCommonDir,
+		repoRoot: settingsContext.repoRoot
+	});
+	stats.setProject(projectKey);
+	progress.estimate(projectKey);
+	let estimatesRead = null;
+	const estimates = () => estimatesRead ??= readEstimates({
+		projectKey,
+		platform: PLATFORM
+	});
+	const settings = resolveSettingsFor(settingsContext);
+	const integration = await selectedProject.load({
+		context: settingsContext,
+		settings
+	});
+	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,
+		runtimeKind: integration.runtimeKind,
+		variantProblem: integration.variantProblem,
+		detectExpo: () => integration.isExpo,
+		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;
+	if (!integration.targets.includes(plan.target.kind)) return fail("STIM_BAD_ARG", `This project integration does not support the ${plan.target.kind} Android target.`, "Use a local Android emulator for this integration.");
+	if (easProfile !== void 0 && !integration.eas) return fail("STIM_BAD_ARG", "This project integration does not support EAS builds.", "Use its local Android build recipe.");
+	const deviceSlotWait = {
+		automatic: plan.target.kind === "hosted" && plan.target.machine === "auto",
+		signal: runCancellationSignal(),
+		waitMs: plan.deviceSlotWaitMs,
+		displayName: basename(root),
+		reclaimIdleMinutes: deviceReclaimIdleMinutesSetting(settings),
+		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 } = buildPlan;
+	const runtimeKind = integration.runtimeKind(buildPlan);
+	const appMode = runtimeKind === "process" ? "process" : runtimeKind === "metro" ? "development" : "release";
+	record.configuration = variant ?? "debug";
+	const hosting = await selectAndroidPlacement({
+		root,
+		slot,
+		target: plan.target,
+		release,
+		appMode,
+		metroCheck,
+		noWait: plan.deviceSlotWaitMs === 0,
+		buildMachine: options.buildMachine,
+		read: options.readHostedAndroid,
+		resolveSerial: resolveAvdSerial,
+		prepare: options.prepareHostedAndroid,
+		automatic: options.automaticDevicePlacement,
+		...integration.eas && 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 (appMode === "development" && (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 = integration.appIds();
+	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)),
+				settingsContext,
+				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(settings);
+			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 ?? integration.runtime({
+		build: buildPlan,
+		prepareMetro,
+		phase
+	});
+	const useBuildCache = buildPlan.cache.read;
+	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 bootPending = false;
+	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);
+			bootPending = remoteDevice?.ctx.backend !== "eas";
+			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();
+				bootPending = false;
+				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;
+	let preparedArtifact;
+	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,
+			recipe: integration.artifact({
+				root,
+				buildLog,
+				writer,
+				settings,
+				buildPlan,
+				target: androidBuildOptions({
+					release,
+					physical,
+					device,
+					variant,
+					deviceAbi,
+					targetAbiOnly: buildPlan.targetAbiOnly,
+					hostedAbi: hostedTarget?.choice.architecture
+				}),
+				phase,
+				out,
+				step: progress.step,
+				estimates
+			}),
+			targetOffloadRefusal: physical ? "device builds build here" : remoteDevice ? "remote device builds build here" : null,
+			buildPlan,
+			cacheProviderConfig,
+			requestedBuildCache,
+			easBuild,
+			androidPackage,
+			record,
+			maxBuilds: limits.maxBuilds,
+			progress: {
+				phase,
+				out,
+				stats,
+				step: progress.step,
+				miss: progress.miss,
+				hit: progress.hit,
+				place: progress.place,
+				waitingOn: progress.waitingOn,
+				waitingFor: progress.waitingFor
+			}
+		}, {
+			acquireLock,
+			releaseLock,
+			waitForBuild,
+			easAuth,
+			resolveRemoteBuild,
+			uploadRemoteBuild,
+			loadCacheProviderModule,
+			acquireSlot,
+			releaseSlot,
+			now
+		});
+		if (!acquiredArtifact.ok) {
+			ccacheActivity = acquiredArtifact.ccache;
+			const { failure } = acquiredArtifact;
+			return fail(failure.code, failure.message, failure.remedy, failure.extra);
+		}
+		const { artifact } = acquiredArtifact;
+		preparedArtifact = artifact;
+		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,
+			appMode,
+			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,
+				bootPending: () => bootPending,
+				apkPath,
+				androidPackage,
+				androidPackageProblem: appIds.androidPackageProblem ?? null,
+				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,
+				readProjectPackage: () => integration.appIds().androidPackage,
+				packageRemedy: integration.packageRemedy,
+				install,
+				launch,
+				launchRelease,
+				resolveDevClientScheme,
+				verifyLaunched,
+				verifyReleaseLaunched,
+				spawn,
+				kill,
+				pidAlive,
+				verifyCollector,
+				writeLaunch,
+				recordBuild,
+				now,
+				out,
+				emit,
+				recordRun,
+				reclaimed,
+				devServer,
+				enterPhase: progress.step,
+				enterActivity: progress.activity,
+				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;
+	} finally {
+		preparedArtifact?.release();
+	}
+}
+//#endregion
+export { runAndroidOperation as i, registerAndroid as n, runAndroid as r, androidCommand as t };