stim 1.21.0 → 1.22.0

package/dist/{android-DUYkNF4u.mjs → android-C7sVmyI9.mjs}

@@ -1,15 +1,17 @@
-import { f as ownership_claim_exports, p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
-import { B as assignSlotDevice, C as saveConfig, D as withConfigLock$1, K as projectDeviceSlots, O as withConfigLockAsync$1, U as deviceSlotPlatforms, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1, q as removeSlotDevice } from "./config-CYcBF478.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-CsJDEXgK.mjs";
-import { l as pidExists, m as signalProcessTreeAsync } from "./metro-DEXpIhHC.mjs";
-import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-CqeBlrEn.mjs";
-import { i as stimDesktopInstalledAsync, n as settingDefault, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-C12we7lz.mjs";
+import { c as declareSpawnsOn, f as stopDeclaringSpawnsOn, g as process_identity_exports, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { C as saveConfig, D as withConfigLock$1, G as projectDeviceSlots, H as deviceSlotPlatforms, K as removeSlotDevice, O as withConfigLockAsync$1, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1, z as assignSlotDevice } from "./config-DlrsduwG.mjs";
+import { n as runOperationFileQuiet, t as runOperationFile, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { c as androidDataPartitionSizeBytes } from "./settings-C7O8A6ZI.mjs";
+import { c as pidExists, p as signalProcessTreeAsync } from "./metro-DiXtA3Ty.mjs";
+import { i as recordCreatedDevice, r as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-x9rN6bhs.mjs";
+import { i as stimDesktopInstalledAsync, n as settingDefault, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-D5OGpYZM.mjs";
 import { isDeepStrictEqual } from "node:util";
 import { join } from "node:path";
 import { ambientEnv, ambientWrite } from "@stim-cli/core";
 import { ANDROID_EMULATOR_APPS, getParkedMax, isJsonObject, loadConfig, settingDefinition } from "@stim-cli/core/state";
 import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$1 } from "path";
 import { existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { rm } from "node:fs/promises";
 import { homedir, tmpdir } from "os";
 //#region src/devices/sim-pool.ts
 const POOL_SETTING_REMEDY = "Run `stim guide settings` for the device pool bounds and where it can be set.";
@@ -124,11 +126,11 @@ function claimParkedOperation(platform, udid) {
 	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
 	return attempt.acquired ?? null;
 }
-function removeParkedAfter(platform, udid, beforeRemove) {
-	return settleParkedAfter(platform, udid, beforeRemove, null);
+function removeParkedAfter(platform, udid, beforeRemove, operation) {
+	return settleParkedAfter(platform, udid, beforeRemove, null, operation);
 }
-function eraseParkedAfter(platform, udid, erase) {
-	return settleParkedAfter(platform, udid, erase, erasedRecord);
+function eraseParkedAfter(platform, udid, erase, operation) {
+	return settleParkedAfter(platform, udid, erase, erasedRecord, operation);
 }
 function erasedRecord(record) {
 	const erased = { ...record };
@@ -138,9 +140,12 @@ function erasedRecord(record) {
 	delete erased.schemeApprovals;
 	return erased;
 }
-async function settleParkedAfter(platform, udid, action, keep) {
+async function settleParkedAfter(platform, udid, action, keep, operation) {
+	operation?.signal.throwIfAborted();
 	const claim = claimParkedOperation(platform, udid);
 	if (!claim) return null;
+	let retained = false;
+	if (operation) declareSpawnsOn(operation, claim);
 	try {
 		const claimed = await withConfigLockAsync$1(() => {
 			const cfg = loadConfig$1();
@@ -164,23 +169,30 @@ async function settleParkedAfter(platform, udid, action, keep) {
 				record,
 				marked
 			};
-		});
+		}, operation?.signal);
 		if (!claimed) return null;
 		let completed = false;
 		let started = false;
 		let settled = null;
 		try {
+			operation?.signal.throwIfAborted();
 			(0, ownership_claim_exports.markClaimChildPending)(claim);
 			try {
 				await action(claimed.record, () => {
 					started = true;
 				});
+			} catch (cause) {
+				if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) {
+					retained = true;
+					throw Object.assign(new WorkspaceProcessCleanupError([.../* @__PURE__ */ new Set([claim, ...cause instanceof WorkspaceProcessCleanupError ? cause.claims : []])], cause.message, "Verify the parked-device operation and its descendants have stopped."), { reportCleanup: true });
+				}
+				throw cause;
 			} finally {
-				(0, ownership_claim_exports.clearClaimChild)(claim);
+				if (!retained) (0, ownership_claim_exports.clearClaimChild)(claim);
 			}
 			completed = true;
 		} finally {
-			await withConfigLockAsync$1(() => {
+			if (!retained) await withConfigLockAsync$1(() => {
 				const cfg = loadConfig$1();
 				if (!cfg) return;
 				const records = readParked(platform, { config: cfg });
@@ -194,11 +206,12 @@ async function settleParkedAfter(platform, udid, action, keep) {
 		}
 		return settled;
 	} finally {
-		(0, ownership_claim_exports.releaseClaim)(claim);
+		if (operation) stopDeclaringSpawnsOn(operation, claim);
+		if (!retained) (0, ownership_claim_exports.releaseClaim)(claim);
 	}
 }
-async function dropParked(platform, udid) {
-	return await removeParkedAfter(platform, udid, () => {}) !== null;
+async function dropParked(platform, udid, operation) {
+	return await removeParkedAfter(platform, udid, () => {}, operation) !== null;
 }
 //#endregion
 //#region src/devices/device-ownership.ts
@@ -487,6 +500,16 @@ function listAvdDeviceProfiles() {
 		"-c"
 	], { timeoutMs: AVDMANAGER_LIST_TIMEOUT_MS }));
 }
+async function listAvdDeviceProfilesAsync({ signal } = {}) {
+	return parseAvdList(await getExecutor().runFileAsync(androidToolPath("avdmanager"), [
+		"list",
+		"device",
+		"-c"
+	], {
+		signal,
+		timeoutMs: AVDMANAGER_LIST_TIMEOUT_MS
+	}));
+}
 function sanitizeAvdLabel(label) {
 	return String(label).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -503,10 +526,12 @@ function ownedAvdName(label) {
 	return `stim-${clean.startsWith("stim-") ? clean.slice(5) : clean}`;
 }
 const AVDMANAGER_DELETE_TIMEOUT_MS = 12e4;
-async function deleteAvd(avdName) {
+async function deleteAvd(avdName, operation) {
+	operation?.signal.throwIfAborted();
 	if (!isStimOwnedAvd(avdName)) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD; Stim has no record of creating it.`);
-	const root = ambientEnv().ANDROID_AVD_HOME ? void 0 : avdStorageRoots().find((candidate) => avdPathExists(join$1(candidate, `${avdName}.ini`)));
-	await getExecutor().runFileAsync(androidToolPath("avdmanager"), [
+	const env = operation?.env ?? ambientEnv();
+	const root = env.ANDROID_AVD_HOME ? void 0 : avdStorageRoots(env).find((candidate) => avdPathExists(join$1(candidate, `${avdName}.ini`)));
+	await runOperationFile(operation, getExecutor(), androidToolPath("avdmanager", process.platform, env), [
 		"delete",
 		"avd",
 		"-n",
@@ -514,6 +539,7 @@ async function deleteAvd(avdName) {
 	], {
 		timeoutMs: AVDMANAGER_DELETE_TIMEOUT_MS,
 		killSignal: "SIGKILL",
+		cwd: operation?.cwd,
 		...root ? { env: { ANDROID_AVD_HOME: root } } : {}
 	});
 	forgetCreatedDevice("android", avdName);
@@ -566,10 +592,12 @@ function listAvds({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS } = {}) {
 		killSignal: "SIGKILL"
 	}));
 }
-async function listAvdsAsync({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS } = {}) {
-	return parseAvdList(await getExecutor().runFileAsync(androidToolPath("emulator"), ["-list-avds"], {
+async function listAvdsAsync({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS, signal, operation } = {}) {
+	return parseAvdList(await runOperationFile(operation, getExecutor(), androidToolPath("emulator", process.platform, operation?.env), ["-list-avds"], {
 		timeoutMs,
-		killSignal: "SIGKILL"
+		killSignal: "SIGKILL",
+		signal,
+		cwd: operation?.cwd
 	}));
 }
 /**
@@ -590,11 +618,12 @@ function listAdbDevices({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS, platform = pro
 		cwd: androidToolCwd(platform)
 	}));
 }
-async function listAdbDevicesAsync({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS, platform = process.platform } = {}) {
-	return parseAdbDevices(await getExecutor().runFileAsync(androidToolPath("adb"), ["devices"], {
+async function listAdbDevicesAsync({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS, platform = process.platform, signal, operation } = {}) {
+	return parseAdbDevices(await runOperationFile(operation, getExecutor(), androidToolPath("adb", platform, operation?.env), ["devices"], {
 		timeoutMs,
 		killSignal: "SIGKILL",
-		cwd: androidToolCwd(platform)
+		cwd: androidToolCwd(platform) ?? operation?.cwd,
+		signal
 	}));
 }
 const ADB_PROP_TIMEOUT_MS = 5e3;
@@ -851,11 +880,14 @@ const AVD_USER_DATA = [
 	"cache.img.qcow2",
 	"snapshots"
 ];
-function wipeAvdUserData(directory) {
-	for (const name of AVD_USER_DATA) rmSync(join$1(directory, name), {
-		recursive: true,
-		force: true
-	});
+async function wipeAvdUserData(directory, signal) {
+	for (const name of AVD_USER_DATA) {
+		signal?.throwIfAborted();
+		await rm(join$1(directory, name), {
+			recursive: true,
+			force: true
+		});
+	}
 }
 function withAvdConfigOverrides(contents, overrides) {
 	const newline = contents.includes("\r\n") ? "\r\n" : "\n";
@@ -1214,27 +1246,42 @@ async function waitForBoot(serial, timeoutMs = 6e4, { aborted = () => false, pol
 }
 const ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS = 6e4;
 const ANDROID_EMULATOR_SHUTDOWN_POLL_MS = 100;
-async function shutdownAndroidEmulator(serial, timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS) {
+async function shutdownAndroidEmulator(serial, timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, operation) {
 	const exec = getExecutor();
 	const started = Date.now();
-	if (await exec.runFileQuietAsync(androidToolPath("adb"), [
+	const run = async (args, budget) => {
+		const options = {
+			timeoutMs: budget,
+			killSignal: "SIGKILL"
+		};
+		if (!operation) return exec.runFileQuietAsync(androidToolPath("adb"), args, options);
+		try {
+			return await runOperationFile(operation, exec, androidToolPath("adb", process.platform, operation.env), args, {
+				...options,
+				cwd: operation.cwd
+			});
+		} catch (cause) {
+			if (cause instanceof WorkspaceProcessCleanupError) throw cause;
+			operation.signal.throwIfAborted();
+			return null;
+		}
+	};
+	if (await run([
 		"-s",
 		serial,
 		"shell",
 		"sync"
-	], {
-		timeoutMs: Math.min(5e3, timeoutMs),
-		killSignal: "SIGKILL"
-	}) === null) ambientWrite("stderr", `warning: could not flush ${serial} before shutdown; shutting it down anyway\n`);
-	await exec.runFileQuietAsync(androidToolPath("adb"), [
+	], Math.min(5e3, timeoutMs)) === null) {
+		const warning = `warning: could not flush ${serial} before shutdown; shutting it down anyway\n`;
+		if (operation) operation.output("stderr", warning);
+		else ambientWrite("stderr", warning);
+	}
+	await run([
 		"-s",
 		serial,
 		"emu",
 		"kill"
-	], {
-		timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)),
-		killSignal: "SIGKILL"
-	});
+	], Math.max(1, timeoutMs - (Date.now() - started)));
 }
 function avdProcessLockPaths(avdDirectory, platform) {
 	return ["hardware-qemu.ini.lock", "userdata-qemu.img.lock"].map((name) => join$1(avdDirectory, name, ...platform === "win32" ? ["pid"] : []));
@@ -1286,9 +1333,9 @@ function listAvdEmulatorProcesses(avdName, platform) {
 	], { timeoutMs: 5e3 });
 	return out === null ? null : parseAvdEmulatorProcesses(out, avdName);
 }
-async function listAvdEmulatorProcessesAsync(avdName, platform) {
+async function listAvdEmulatorProcessesAsync(avdName, platform, operation) {
 	if (platform === "win32") return [];
-	const out = await getExecutor().runFileQuietAsync("ps", [
+	const out = await runOperationFileQuiet(operation, getExecutor(), "ps", [
 		"-axww",
 		"-o",
 		"pid=,command="
@@ -1320,14 +1367,36 @@ function assertOwnedAvdStopped(avdName, { processAlive = emulatorProcessRunning,
 	if (processId !== null && processAlive(processId)) live.add(processId);
 	if (live.size) throw new Error(`Owned AVD ${avdName} still has a live emulator process (${[...live].join(", ")}).`);
 }
+/** Async stopped-emulator verification; cancellation and unresolved probe cleanup propagate. */
+async function assertOwnedAvdStoppedAsync(avdName, operation, resolveDirectory = ownedAvdDirectory) {
+	operation?.signal.throwIfAborted();
+	const { processId } = resolveAvdProcess(avdName, { resolveDirectory });
+	const processes = await listAvdEmulatorProcessesAsync(avdName, process.platform, operation);
+	if (processes === null) throw new Error(`Could not read the process table to verify that owned AVD ${avdName} stopped.`);
+	const live = new Set(processes);
+	if (processId !== null && pidExists(processId)) {
+		const stat = process.platform === "win32" ? null : await runOperationFileQuiet(operation, getExecutor(), "ps", [
+			"-o",
+			"stat=",
+			"-p",
+			String(processId)
+		], {
+			timeoutMs: 5e3,
+			killSignal: "SIGKILL",
+			cwd: operation?.cwd
+		});
+		if (stat === null || !stat.trim().startsWith("Z")) live.add(processId);
+	}
+	if (live.size) throw new Error(`Owned AVD ${avdName} still has a live emulator process (${[...live].join(", ")}).`);
+}
 const CRASH_HANDLER_EXIT_TIMEOUT_MS = 15e3;
 /**
 * The crashpad handler qemu forks on Windows. It outlives an emulator that crashes on exit while
 * it writes the dump, so a `stop` that returns on qemu's exit leaves it running.
 * https://github.com/appandflow/stim/issues/918
 */
-async function emulatorCrashHandlerPids(qemuPid) {
-	const out = await getExecutor().runFileQuietAsync("powershell.exe", [
+async function emulatorCrashHandlerPids(qemuPid, operation) {
+	const out = await runOperationFileQuiet(operation, getExecutor(), "powershell.exe", [
 		"-NoProfile",
 		"-NonInteractive",
 		"-Command",
@@ -1346,14 +1415,26 @@ const EMULATOR_SIGNAL_GRACE_MS = 5e3;
 * grace, but only a process whose command line names this AVD and whose identity, captured before
 * shutdown, still matches. Windows has no process-table scan, so there nothing is signalled.
 */
-async function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, pollMs = ANDROID_EMULATOR_SHUTDOWN_POLL_MS, signalGraceMs = EMULATOR_SIGNAL_GRACE_MS, platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId, processAlive = pidExists, listProcesses = listAvdEmulatorProcessesAsync, captureIdentity = process_identity_exports.captureProcessIdentity, inspectIdentity = process_identity_exports.inspectProcessIdentity, signal = (pid, name) => signalProcessTreeAsync(pid, name, { platform }), directoryExists = (path) => statSync(path).isDirectory(), crashHandlerPids = emulatorCrashHandlerPids, killCrashHandler = (pid) => signalProcessTreeAsync(pid, "SIGKILL", { platform }), now = Date.now, sleep = (ms) => new Promise((done) => setTimeout(done, ms)) } = {}) {
+async function waitForAndroidEmulatorShutdown(avdName, shutdown, { operation, timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, pollMs = ANDROID_EMULATOR_SHUTDOWN_POLL_MS, signalGraceMs = EMULATOR_SIGNAL_GRACE_MS, platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId, processAlive = pidExists, listProcesses = (name, host) => listAvdEmulatorProcessesAsync(name, host, operation), captureIdentity = process_identity_exports.captureProcessIdentity, inspectIdentity = process_identity_exports.inspectProcessIdentity, signal = (pid, name) => signalProcessTreeAsync(pid, name, {
+	platform,
+	operation
+}), directoryExists = (path) => statSync(path).isDirectory(), crashHandlerPids = (pid) => emulatorCrashHandlerPids(pid, operation), killCrashHandler = (pid) => signalProcessTreeAsync(pid, "SIGKILL", {
+	platform,
+	operation
+}), now = Date.now, sleep = (ms) => cancellableSleep(ms, {
+	signal: operation?.signal,
+	what: "emulator shutdown"
+}) } = {}) {
+	operation?.signal.throwIfAborted();
 	const { directory, processId } = resolveAvdProcess(avdName, {
 		platform,
 		resolveDirectory,
 		readProcessId
 	});
 	const scan = async () => {
+		operation?.signal.throwIfAborted();
 		const pids = await listProcesses(avdName, platform);
+		operation?.signal.throwIfAborted();
 		if (pids === null) throw new Error(`Could not read the process table to verify that owned AVD ${avdName} stopped.`);
 		return pids;
 	};
@@ -1382,6 +1463,7 @@ async function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = A
 	};
 	const waitUntil = async (until) => {
 		for (;;) {
+			operation?.signal.throwIfAborted();
 			if (running().length === 0) return true;
 			const remaining = until - now();
 			if (remaining <= 0) return false;
@@ -1396,14 +1478,18 @@ async function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = A
 		await waitUntil(deadline);
 	}
 	for (const name of ["SIGTERM", "SIGKILL"]) {
+		operation?.signal.throwIfAborted();
 		const verified = running().filter((pid) => {
 			const record = identities.get(pid);
 			return record && inspectIdentity(record) === "same";
 		});
 		if (verified.length === 0) break;
-		for (const pid of verified) try {
-			await signal(pid, name);
-		} catch {}
+		for (const pid of verified) {
+			operation?.signal.throwIfAborted();
+			try {
+				await signal(pid, name);
+			} catch {}
+		}
 		const graceMs = name === "SIGTERM" && !shutdown ? timeoutMs : signalGraceMs;
 		if (await waitUntil(now() + graceMs)) break;
 	}
@@ -1424,7 +1510,11 @@ async function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = A
 	if (platform === "win32" && processId !== null) {
 		const handlerDeadline = now() + CRASH_HANDLER_EXIT_TIMEOUT_MS;
 		for (const handler of await crashHandlerPids(processId)) {
-			while (processAlive(handler) && now() < handlerDeadline) await sleep(pollMs);
+			while (processAlive(handler) && now() < handlerDeadline) {
+				operation?.signal.throwIfAborted();
+				await sleep(pollMs);
+			}
+			operation?.signal.throwIfAborted();
 			if (processAlive(handler)) {
 				await killCrashHandler(handler);
 				if (processAlive(handler)) throw new Error(`Crashpad handler ${handler} for owned AVD ${avdName} stayed alive.`);
@@ -1448,17 +1538,22 @@ function getAvdNameForSerial(serial, { timeoutMs = EMU_AVD_NAME_TIMEOUT_MS } = {
 	if (!out) return null;
 	return out.split("\n")[0]?.trim() || null;
 }
-async function getAvdNameForSerialAsync(serial, { timeoutMs = EMU_AVD_NAME_TIMEOUT_MS } = {}) {
-	const out = await getExecutor().runFileQuietAsync(androidToolPath("adb"), [
+async function getAvdNameForSerialAsync(serial, { timeoutMs = EMU_AVD_NAME_TIMEOUT_MS, signal, operation } = {}) {
+	const tool = androidToolPath("adb", process.platform, operation?.env);
+	const args = [
 		"-s",
 		serial,
 		"emu",
 		"avd",
 		"name"
-	], {
+	];
+	const options = {
 		timeoutMs: Math.min(timeoutMs, EMU_AVD_NAME_TIMEOUT_MS),
-		killSignal: "SIGKILL"
-	});
+		killSignal: "SIGKILL",
+		signal,
+		cwd: androidToolCwd() ?? operation?.cwd
+	};
+	const out = await runOperationFileQuiet(operation, getExecutor(), tool, args, options);
 	if (!out) return null;
 	return out.split("\n")[0]?.trim() || null;
 }
@@ -1467,9 +1562,13 @@ async function resolveOwnedAvdSerialAsync(avdName, opts = {}) {
 	return ownedAvdSerialResolverAsync(opts)(avdName);
 }
 /** Shares bounded asynchronous AVD, adb and emulator-name reads across the requested AVDs. */
-function ownedAvdSerialResolverAsync({ timeoutMs } = {}) {
+function ownedAvdSerialResolverAsync({ timeoutMs, signal, operation } = {}) {
 	const started = Date.now();
-	const remaining = () => ({ timeoutMs: timeoutMs === void 0 ? void 0 : Math.max(MIN_LOOKUP_TIMEOUT_MS, timeoutMs - (Date.now() - started)) });
+	const remaining = () => ({
+		signal,
+		operation,
+		timeoutMs: timeoutMs === void 0 ? void 0 : Math.max(MIN_LOOKUP_TIMEOUT_MS, timeoutMs - (Date.now() - started))
+	});
 	const avds = once(() => listAvdsAsync(remaining()));
 	const adb = once(() => listAdbDevicesAsync(remaining()));
 	const names = /* @__PURE__ */ new Map();
@@ -1482,9 +1581,11 @@ function ownedAvdSerialResolverAsync({ timeoutMs } = {}) {
 		return name;
 	};
 	return async (avdName) => {
+		signal?.throwIfAborted();
 		if (!(await avds()).includes(avdName)) return { missing: true };
 		if (!isStimOwnedAvd(avdName)) return { notOwned: true };
 		const devices = await adb();
+		signal?.throwIfAborted();
 		const candidates = [...devices.emulators, ...devices.unhealthy.filter((entry) => entry.kind === "emulator" && entry.consolePort !== void 0)];
 		for (const candidate of candidates) if (await avdNameOf(candidate.serial) === avdName) return { serial: candidate.serial };
 		return { notRunning: true };
@@ -1530,4 +1631,4 @@ function ownedAvdSerialResolver({ timeoutMs } = {}) {
 	};
 }
 //#endregion
-export { resolvePhysicalDevice as $, listAdbDevicesAsync as A, ownedAvdMatchesConfiguration as B, emulatorFailureRemedy as C, getAvdNameForSerialAsync as D, getAvdNameForSerial as E, listOrphanedAvdDirectories as F, parseAvdDeviceProfile as G, ownedAvdSerialResolver as H, memoizeEmulatorProbe as I, pickDefaultSystemImage as J, parseAvdSystemImage as K, nextConsolePort as L, listAvds as M, listAvdsAsync as N, hostSystemImageArch as O, listInstalledSystemImages as P, resolveOwnedAvdSerialAsync as Q, ownedAvdDeviceProfile as R, emulatorDiskSpaceRemedy as S, findBuildTool as T, ownedAvdSerialResolverAsync as U, ownedAvdName as V, ownedAvdSystemImage as W, profileNeedsFoldFeature as X, probeEmulatorSerial as Y, resetAdoptedAvd as Z, avdStorageRoots as _, removeParkedAfter as _t, androidDeviceAbi as a, wipeAvdUserData as at, createOwnedAvd as b, androidPoolNoCandidatesRefusal as c, isStimOwnedSim as ct, androidToolPath as d, dropParked as dt, shutdownAndroidEmulator as et, assertOwnedAvdStopped as f, eraseParkedAfter as ft, avdPoolConfiguration as g, readParked as gt, avdPathExists as h, parkedMaxSetting as ht, androidDataFreeBytes as i, waitForBoot as it, listAvdDeviceProfiles as j, listAdbDevices as k, androidSystemImageAbi as l, POOL_SETTING_REMEDY as lt, avdNameAbsent as m, parkSim as mt, OWNED_AVD_CONFIG_DEFAULTS as n, trimAndroidCaches as nt, androidHome as o, configuredAndroidEmulatorApp as ot, avdIniPaths as p, isLegacyDeletionClaim as pt, physicalDeviceModel as q, androidBuildToolName as r, waitForAndroidEmulatorShutdown as rt, androidPoolCandidates as s, isStimOwnedAvd as st, DEFAULT_AVD_DEVICE_PROFILE as t, systemImageSupportsFold as tt, androidToolCwd as u, adoptParked as ut, bootAndroidEmulator as v, selectParked as vt, extractEmulatorFailure as w, deleteAvd as x, configureNewOwnedAvd as y, ownedAvdDirectory as z };
+export { resetAdoptedAvd as $, listAdbDevices as A, ownedAvdDeviceProfile as B, emulatorDiskSpaceRemedy as C, getAvdNameForSerial as D, findBuildTool as E, listAvdsAsync as F, ownedAvdSerialResolverAsync as G, ownedAvdMatchesConfiguration as H, listInstalledSystemImages as I, parseAvdSystemImage as J, ownedAvdSystemImage as K, listOrphanedAvdDirectories as L, listAvdDeviceProfiles as M, listAvdDeviceProfilesAsync as N, getAvdNameForSerialAsync as O, listAvds as P, profileNeedsFoldFeature as Q, memoizeEmulatorProbe as R, deleteAvd as S, extractEmulatorFailure as T, ownedAvdName as U, ownedAvdDirectory as V, ownedAvdSerialResolver as W, pickDefaultSystemImage as X, physicalDeviceModel as Y, probeEmulatorSerial as Z, avdPoolConfiguration as _, parkedMaxSetting as _t, androidDeviceAbi as a, waitForAndroidEmulatorShutdown as at, configureNewOwnedAvd as b, selectParked as bt, androidPoolNoCandidatesRefusal as c, configuredAndroidEmulatorApp as ct, androidToolPath as d, POOL_SETTING_REMEDY as dt, resolveOwnedAvdSerialAsync as et, assertOwnedAvdStopped as f, adoptParked as ft, avdPathExists as g, parkSim as gt, avdNameAbsent as h, isLegacyDeletionClaim as ht, androidDataFreeBytes as i, trimAndroidCaches as it, listAdbDevicesAsync as j, hostSystemImageArch as k, androidSystemImageAbi as l, isStimOwnedAvd as lt, avdIniPaths as m, eraseParkedAfter as mt, OWNED_AVD_CONFIG_DEFAULTS as n, shutdownAndroidEmulator as nt, androidHome as o, waitForBoot as ot, assertOwnedAvdStoppedAsync as p, dropParked as pt, parseAvdDeviceProfile as q, androidBuildToolName as r, systemImageSupportsFold as rt, androidPoolCandidates as s, wipeAvdUserData as st, DEFAULT_AVD_DEVICE_PROFILE as t, resolvePhysicalDevice as tt, androidToolCwd as u, isStimOwnedSim as ut, avdStorageRoots as v, readParked as vt, emulatorFailureRemedy as w, createOwnedAvd as x, bootAndroidEmulator as y, removeParkedAfter as yt, nextConsolePort as z };

package/dist/{android-CV_GCELZ.mjs → android-DGkNqa_c.mjs}

@@ -1,6 +1,6 @@
-import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-B1UrjZHL.mjs";
-import { E as resolveVariant, T as resolveSystemImage, _ as findAapt, b as noDeviceDiagnostic, d as androidVariantSetting, f as apkDevClientFacts, g as dumpApkManifest, h as displayPath, i as NO_FINGERPRINT, p as apkPackage, r as NO_DEVICE, s as androidDevClientScheme, u as androidSystemImageSetting, x as parseXmltree, y as isReleaseVariant } from "./support-67vraa1Q.mjs";
-import { r as lastBuildRecord, t as androidFacts } from "./result-DNiS-tTP.mjs";
-import { i as runAndroidOperation, n as registerAndroid, r as runAndroid, t as androidCommand } from "./android-BLgbNqox.mjs";
-import { a as killPreviousCollector, i as collectorLogFile, o as startCollector } from "./launch-CD1yVc7U.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-gwpm28fu.mjs";
+import { E as resolveVariant, T as resolveSystemImage, _ as findAapt, b as noDeviceDiagnostic, d as androidVariantSetting, f as apkDevClientFacts, g as dumpApkManifest, h as displayPath, i as NO_FINGERPRINT, p as apkPackage, r as NO_DEVICE, s as androidDevClientScheme, u as androidSystemImageSetting, x as parseXmltree, y as isReleaseVariant } from "./support-yUiOjnVY.mjs";
+import { r as lastBuildRecord, t as androidFacts } from "./result-D2Ykz_iD.mjs";
+import { i as runAndroidOperation, n as registerAndroid, r as runAndroid, t as androidCommand } from "./android-ByRMUoiJ.mjs";
+import { a as killPreviousCollector, i as collectorLogFile, o as startCollector } from "./launch-CCzXlc8r.mjs";
 export { NO_DEVICE, NO_FINGERPRINT, androidDevClientScheme, androidFacts, androidSystemImageSetting, androidVariantSetting, apkDevClientFacts, apkPackage, collectorLogFile, androidCommand as default, displayPath, dumpApkManifest, findAapt, formatDuration, isReleaseVariant, killPreviousCollector, lastBuildRecord, noDeviceDiagnostic, parseXmltree, phaseLine, registerAndroid, resolveSystemImage, resolveVariant, runAndroid, runAndroidOperation, shortHash, startCollector };

package/dist/{android-BEJ8Jpl7.mjs → android-DR5lZ2Az.mjs}

@@ -1,5 +1,5 @@
-import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
-import { u as androidToolCwd } from "./android-DUYkNF4u.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { u as androidToolCwd } from "./android-C7sVmyI9.mjs";
 //#region src/collector/android.ts
 const LEVEL_BY_LETTER = {
 	V: "debug",

package/dist/android-cas-compiler.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/{android-cas-Ct5b1xCK.mjs → android-cas-ngferVq2.mjs}

@@ -1,7 +1,7 @@
 import { n as ensureWorkspaceStorage, v as withDirLock$1 } from "./paths-DQtTgsBf.mjs";
-import { d as getConfigDir } from "./config-CYcBF478.mjs";
-import { m as defaultAndroidLayout } from "./settings-CsJDEXgK.mjs";
-import { r as register } from "./cache-manifest-DkkqguoK.mjs";
+import { d as getConfigDir } from "./config-DlrsduwG.mjs";
+import { m as defaultAndroidLayout } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/{client-B7QVOlCr.d.mts → android-project-DVWyCbWU.d.mts}

@@ -1,11 +1,15 @@
-import "./settings-DkdmlelE.mjs";
-import "./exec-H20xSg2T.mjs";
-import { StimContext } from "@stim-cli/core";
-import { Endpoint } from "@stim-cli/core/state";
+import { n as SettingsObject, t as AndroidLayout } from "./ios-CDvlmUs7.mjs";
+import { r as createNdjsonWriter } from "./exec-DnYc4HGH.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { StimContext, hostSimulatorArch } from "@stim-cli/core";
+import { ANDROID_EMULATOR_APPS, BuildPhase, BuildPlanPayload, Endpoint, RunEstimates, SettingScope, WebViewport, machineCapacity } from "@stim-cli/core/state";
 import "@stim-cli/core/noise-session";
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync$1 } from "fs";
+import { Command } from "commander";
 import "@expo/fingerprint";
-import { HelloResult } from "@stim-cli/core/protocol";
+import { CacheProviderConfig, loadCacheProvider } from "@stim-cli/cache";
+import { BuildReactNativeArtifactQuery, BuildSwiftpmArtifactQuery, GradleOffloadInputs, HelloResult } from "@stim-cli/core/protocol";
+import { ChildProcess } from "node:child_process";
 //#region src/engine/build-facts.d.ts
 type CacheHitLevel = "local" | "remote" | false;
 type LaunchStatus = boolean | "unverified" | "bundling";
@@ -143,6 +147,23 @@ interface CompilerCacheFallback {
   fromEnvironment: boolean;
   manifest: string | null;
 }
+declare function artifactCachePolicy(options: Optimizations, reuse: boolean, release: boolean): {
+  read: boolean;
+  write: boolean;
+  remote: boolean;
+};
+//#endregion
+//#region src/engine/android-cas.d.ts
+interface AndroidCasSetup {
+  id: string;
+  dir: string;
+  initScript: string;
+  env: Record<string, string>;
+}
+declare function resolveAndroidCas(root: string, env?: NodeJS.ProcessEnv, layout?: AndroidLayout): AndroidCasSetup | null;
+//#endregion
+//#region src/commands/android/types.d.ts
+type AndroidWriter = ReturnType<typeof createNdjsonWriter>;
 //#endregion
 //#region src/diagnostics/doctor.d.ts
 interface Finding {
@@ -154,7 +175,73 @@ interface Finding {
 }
 type DoctorPlatform = "ios" | "android";
 //#endregion
+//#region src/budget.d.ts
+type ReclaimStepName = "idle-devices" | "idle-dev-servers" | "workspace-outputs" | "stale-cache-entries";
+interface ReclaimedStep {
+  step: ReclaimStepName;
+  targets: string[];
+  failures: number;
+  freedMb?: number;
+}
+interface BudgetReport {
+  budget: {
+    minFreeDiskGb: number;
+    hardFloorDiskGb: number;
+    maxCommittedMemoryGb: number;
+    maxLiveWorkspaces: number;
+  };
+  volumes: {
+    volume: string;
+    freeGb: number;
+  }[];
+  memory: {
+    committedGb: number;
+    liveWorkspaces: number;
+  } | null;
+  plan: ReclaimedStep[];
+}
+//#endregion
+//#region src/commands/android/plan.d.ts
+interface AndroidBuildPlan {
+  readonly build: {
+    readonly variant: string | null;
+    readonly release: boolean;
+    readonly profile: string | undefined;
+    readonly cas: ReturnType<typeof resolveAndroidCas>;
+    readonly cache: Readonly<ReturnType<typeof artifactCachePolicy>>;
+    readonly compilerCache: Optimizations["android"]["compilerCache"];
+    readonly gradleBuildCache: boolean;
+    readonly pch: Optimizations["android"]["pch"];
+    readonly targetAbiOnly: boolean;
+  };
+  readonly metroWarmup: boolean;
+  readonly cacheProviderConfig: CacheProviderConfig | null;
+}
+//#endregion
 //#region src/offload/toolchain.d.ts
+/** What must be identical on this Mac and a remote Mac for an iOS simulator build to come out the same. */
+interface IosToolchain {
+  /** A digest of Stim's built code, so both sides prove they run the same Stim. */
+  stimBuild: string | null;
+  arch: string;
+  xcode: string | null;
+  simulatorSdk: string | null;
+  cocoapods: string | null;
+}
+/** A remote machine's toolchain, the simulator runtimes it can build for, and its JDK and Android SDK packages. */
+interface WorkerToolchain extends IosToolchain {
+  /** The OS stim-server runs on, as Node names it; absent from a stim-server older than this field. */
+  os?: string;
+  macosSdk: string | null;
+  bundler: string | null;
+  runtimes: string[];
+  jdk: string | null;
+  androidSdk: {
+    ndk: string[];
+    buildTools: string[];
+    platforms: string[];
+  } | null;
+}
 /** One reason a remote machine cannot take this build now, with a stable `code` for doctor's JSON. */
 interface OffloadProblem {
   code: "unreachable" | "checkout" | "stim-build" | "arch" | "xcode" | "macos-sdk" | "simulator-sdk" | "cocoapods" | "bundler" | "runtime" | "jdk" | "android-sdk" | "ndk" | "build-tools" | "compile-sdk" | "disk" | "busy" | "platform";
@@ -250,4 +337,55 @@ interface AndroidBuildOptions {
   module?: string | null;
 }
 //#endregion
-export { DoctorPlatform as a, AndroidFacts as c, IosFacts as d, TailnetMachineIo as i, CcacheActivity as l, BuildMachinesInspection as n, Finding as o, GeneratedTickets as r, Optimizations as s, AndroidBuildOptions as t, CompilationCacheActivity as u };
+//#region src/integrations/swiftpm-artifact-inputs.d.ts
+interface SwiftpmArtifactToolchain {
+  swift: string;
+  sdk: string;
+  arch: string;
+  xcode: string;
+}
+//#endregion
+//#region src/web/launch.d.ts
+type WebLaunched = true | "bundling" | "unverified";
+//#endregion
+//#region src/integrations/native-gradle-artifact-inputs.d.ts
+interface GradleArtifactInputs extends GradleOffloadInputs {
+  localFiles: string[];
+  environment: string[];
+}
+type GradleArtifactBuild = Pick<AndroidArtifactContext["buildPlan"], "variant" | "compilerCache" | "gradleBuildCache" | "pch" | "cas">;
+interface NativeGradleArtifactReceipt {
+  source: string;
+  declaration: GradleArtifactInputs;
+  build: GradleArtifactBuild;
+  abi: string | null;
+}
+//#endregion
+//#region src/integrations/android-project.d.ts
+interface AndroidBuildTarget {
+  abi: string | null;
+}
+interface AndroidArtifactIdentity {
+  hash: string;
+  key: string;
+}
+interface AndroidArtifactContext {
+  operation?: StimContext;
+  artifactScope?: {
+    key: string;
+    validate(): Promise<void>;
+    record?(identity: AndroidArtifactIdentity, receipt: NativeGradleArtifactReceipt): void;
+  };
+  root: string;
+  buildLog: string;
+  writer: AndroidWriter;
+  settings: SettingsObject;
+  buildPlan: AndroidBuildPlan["build"];
+  target: AndroidBuildTarget;
+  phase: (label: unknown, text: string) => void;
+  out: (line: string) => void;
+  step: (phase: BuildPhase) => void;
+  estimates: () => RunEstimates;
+}
+//#endregion
+export { IosFacts as _, BuildMachinesInspection as a, IosToolchain as c, DoctorPlatform as d, Finding as f, CompilationCacheActivity as g, CcacheActivity as h, AndroidBuildOptions as i, WorkerToolchain as l, AndroidFacts as m, WebLaunched as n, GeneratedTickets as o, Optimizations as p, SwiftpmArtifactToolchain as r, TailnetMachineIo as s, NativeGradleArtifactReceipt as t, BudgetReport as u };