stim 1.20.2 → 1.22.0

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

@@ -1,32 +1,18 @@
-import { C as saveConfig, D as withConfigLock$1, G as removeSlotDevice, R as assignSlotDevice, V as deviceSlotPlatforms, W as projectDeviceSlots, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1, j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-B717odTD.mjs";
-import { n as settingDefault, r as stimDesktopInstalled, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-BzBN2Em2.mjs";
-import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-Dzd5C2LF.mjs";
-import { d as signalProcessTree, s as pidExists } from "./metro-DnCEjCxs.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 { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$1 } from "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";
-import { isDeepStrictEqual } from "node:util";
-//#region src/devices/android-emulator-viewer.ts
-function configuredAndroidEmulatorApp(platform = process.platform) {
-	const value = loadConfig$1()?.androidEmulatorApp ?? settingDefault(settingDefinition("androidEmulatorApp"), () => stimDesktopInstalled(platform)).value;
-	if (ANDROID_EMULATOR_APPS.includes(value)) return value;
-	const error = /* @__PURE__ */ new Error("Invalid androidEmulatorApp in machine config. Use \"emulator\" or \"stim-desktop\".");
-	Object.assign(error, { code: "STIM_BAD_ARG" });
-	throw error;
-}
-function openEmulatorInStimDesktop(serial) {
-	getExecutor().runFileQuiet("open", [
-		"-g",
-		"-a",
-		"Stim",
-		`stim-desktop://open?serial=${serial}`
-	], STIM_DESKTOP_OPEN_OPTIONS);
-}
-//#endregion
 //#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.";
 function parkedMaxSetting(platform, options = {}) {
@@ -140,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 };
@@ -154,11 +140,14 @@ function erasedRecord(record) {
 	delete erased.schemeApprovals;
 	return erased;
 }
-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 = withConfigLock$1(() => {
+		const claimed = await withConfigLockAsync$1(() => {
 			const cfg = loadConfig$1();
 			if (!cfg) return null;
 			const records = readParked(platform, { config: cfg });
@@ -180,23 +169,30 @@ 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 {
-				action(claimed.record, () => {
+				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 {
-			withConfigLock$1(() => {
+			if (!retained) await withConfigLockAsync$1(() => {
 				const cfg = loadConfig$1();
 				if (!cfg) return;
 				const records = readParked(platform, { config: cfg });
@@ -210,11 +206,12 @@ 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);
 	}
 }
-function dropParked(platform, udid) {
-	return removeParkedAfter(platform, udid, () => {}) !== null;
+async function dropParked(platform, udid, operation) {
+	return await removeParkedAfter(platform, udid, () => {}, operation) !== null;
 }
 //#endregion
 //#region src/devices/device-ownership.ts
@@ -246,6 +243,27 @@ function isStimOwnedAvd(name) {
 	return name.startsWith("stim-") && isStimOwnedDevice("android", name);
 }
 //#endregion
+//#region src/devices/android-emulator-viewer.ts
+async function configuredAndroidEmulatorApp(platform = process.platform, env) {
+	let value = loadConfig$1()?.androidEmulatorApp;
+	if (value === void 0) {
+		const installed = await stimDesktopInstalledAsync(platform, env);
+		value = settingDefault(settingDefinition("androidEmulatorApp"), () => installed).value;
+	}
+	if (ANDROID_EMULATOR_APPS.includes(value)) return value;
+	const error = /* @__PURE__ */ new Error("Invalid androidEmulatorApp in machine config. Use \"emulator\" or \"stim-desktop\".");
+	Object.assign(error, { code: "STIM_BAD_ARG" });
+	throw error;
+}
+async function openEmulatorInStimDesktop(serial) {
+	await getExecutor().runFileQuietAsync("open", [
+		"-g",
+		"-a",
+		"Stim",
+		`stim-desktop://open?serial=${serial}`
+	], STIM_DESKTOP_OPEN_OPTIONS);
+}
+//#endregion
 //#region src/devices/android.ts
 const ANDROID_ABIS = /* @__PURE__ */ new Set([
 	"armeabi-v7a",
@@ -254,11 +272,13 @@ const ANDROID_ABIS = /* @__PURE__ */ new Set([
 	"x86_64"
 ]);
 const DEFAULT_AVD_DEVICE_PROFILE = String(settingDefinition("android.deviceProfile")?.default);
-function androidHome(env = process.env) {
+function androidHome(env = ambientEnv()) {
 	const configured = env.ANDROID_HOME || env.ANDROID_SDK_ROOT;
 	if (configured) return configured;
-	if (process.platform === "win32") return join$1(env.LOCALAPPDATA || join$1(homedir(), "AppData", "Local"), "Android", "Sdk");
-	return join$1(homedir(), "Library", "Android", "sdk");
+	const home = process.platform === "win32" ? env.USERPROFILE || homedir() : env.HOME || homedir();
+	if (process.platform === "win32") return join$1(env.LOCALAPPDATA || join$1(home, "AppData", "Local"), "Android", "Sdk");
+	if (process.platform === "linux") return join$1(home, "Android", "Sdk");
+	return join$1(home, "Library", "Android", "sdk");
 }
 const SDK_TOOL_LOCATIONS = {
 	emulator: ["emulator", "emulator"],
@@ -282,11 +302,11 @@ const WINDOWS_SDK_TOOL_EXTENSIONS = {
 	avdmanager: ".bat",
 	sdkmanager: ".bat"
 };
-function androidToolPath(tool, platform = process.platform) {
+function androidToolPath(tool, platform = process.platform, env = ambientEnv()) {
 	const location = SDK_TOOL_LOCATIONS[tool];
 	const bare = location.at(-1);
 	const name = platform === "win32" ? `${bare}${WINDOWS_SDK_TOOL_EXTENSIONS[tool]}` : bare;
-	const abs = join$1(androidHome(), ...location.slice(0, -1), name);
+	const abs = join$1(androidHome(env), ...location.slice(0, -1), name);
 	return existsSync(abs) ? abs : bare;
 }
 const WINDOWS_BUILD_TOOL_EXTENSIONS = { apksigner: ".bat" };
@@ -333,8 +353,8 @@ function findBuildTool(tools, { home = androidHome(), readDir = readdirSync, exi
 	}
 	return null;
 }
-function listInstalledSystemImages(onUnreadable) {
-	const root = join$1(androidHome(), "system-images");
+function listInstalledSystemImages(onUnreadable, env = ambientEnv()) {
+	const root = join$1(androidHome(env), "system-images");
 	const images = [];
 	const list = (dir) => {
 		try {
@@ -402,9 +422,9 @@ async function createOwnedAvd(label, { systemImage, deviceProfile = DEFAULT_AVD_
 		"--device",
 		deviceProfile
 	];
-	let env = process.env;
+	let env = ambientEnv();
 	if (!env.ANDROID_AVD_HOME) {
-		const root = avdLookupRoots(env, homedir())[0];
+		const root = avdLookupRoots(env, (process.platform === "win32" ? env.USERPROFILE : env.HOME) || homedir())[0];
 		mkdirSync(root, { recursive: true });
 		env = {
 			...env,
@@ -480,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, "");
 }
@@ -496,10 +526,12 @@ function ownedAvdName(label) {
 	return `stim-${clean.startsWith("stim-") ? clean.slice(5) : clean}`;
 }
 const AVDMANAGER_DELETE_TIMEOUT_MS = 12e4;
-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 = process.env.ANDROID_AVD_HOME ? void 0 : avdStorageRoots().find((candidate) => avdPathExists(join$1(candidate, `${avdName}.ini`)));
-	getExecutor().runFile(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",
@@ -507,6 +539,7 @@ function deleteAvd(avdName) {
 	], {
 		timeoutMs: AVDMANAGER_DELETE_TIMEOUT_MS,
 		killSignal: "SIGKILL",
+		cwd: operation?.cwd,
 		...root ? { env: { ANDROID_AVD_HOME: root } } : {}
 	});
 	forgetCreatedDevice("android", avdName);
@@ -559,6 +592,14 @@ function listAvds({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS } = {}) {
 		killSignal: "SIGKILL"
 	}));
 }
+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",
+		signal,
+		cwd: operation?.cwd
+	}));
+}
 /**
 * Working directory for the adb client and the emulator Stim starts. Both leave processes behind
 * that inherit it: the adb server is spawned by whichever client finds none running, and the
@@ -577,6 +618,14 @@ function listAdbDevices({ timeoutMs = ANDROID_LISTING_TIMEOUT_MS, platform = pro
 		cwd: androidToolCwd(platform)
 	}));
 }
+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) ?? operation?.cwd,
+		signal
+	}));
+}
 const ADB_PROP_TIMEOUT_MS = 5e3;
 const EMULATOR_HARDWARE = /* @__PURE__ */ new Set([
 	"ranchu",
@@ -688,7 +737,7 @@ function nextConsolePort(claimedPorts) {
 	if (claimedPorts.length === 0) return 5554;
 	return Math.max(...claimedPorts) + 2;
 }
-function headlessEmulatorArgs(env = process.env, platform = process.platform, app = "emulator") {
+function headlessEmulatorArgs(env = ambientEnv(), platform = process.platform, app = "emulator") {
 	const args = [];
 	if (platform === "darwin" && app === "stim-desktop") args.push("-no-window", "-gpu", "host");
 	if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) args.push("-no-window", "-noaudio", "-no-boot-anim", "-gpu", "swiftshader_indirect", "-no-snapshot-save", "-no-snapshot-load");
@@ -717,15 +766,15 @@ function avdIniPaths(root, ini) {
 	const parsed = parseAvdRootIni(ini);
 	return [parsed.relativePath && !isAbsolute$1(parsed.relativePath) ? resolve$1(dirname$1(root), parsed.relativePath) : null, parsed.path && isAbsolute$1(parsed.path) ? parsed.path : null].filter((candidate) => candidate !== null);
 }
-function avdStorageRoots() {
-	const env = process.env;
+function avdStorageRoots(env = ambientEnv()) {
+	const home = process.platform === "win32" ? env.USERPROFILE || homedir() : env.HOME || homedir();
 	return [...new Set([
 		env.ANDROID_AVD_HOME,
 		env.ANDROID_EMULATOR_HOME ? join$1(env.ANDROID_EMULATOR_HOME, "avd") : null,
 		env.ANDROID_USER_HOME ? join$1(env.ANDROID_USER_HOME, "avd") : null,
 		env.ANDROID_SDK_HOME ? join$1(env.ANDROID_SDK_HOME, ".android", "avd") : null,
 		env.ANDROID_SDK_HOME ? join$1(env.ANDROID_SDK_HOME, "avd") : null,
-		join$1(homedir(), ".android", "avd")
+		join$1(home, ".android", "avd")
 	].filter((value) => Boolean(value)))];
 }
 function avdPathExists(path) {
@@ -803,7 +852,7 @@ function avdLookupRoots(env, home) {
 	];
 	return [...new Set(roots.filter((value) => Boolean(value)))];
 }
-function ownedAvdDirectory(avdName, { env = process.env, home = homedir(), readFile = (path) => readFileSync(path, "utf8"), realpath = realpathSync, isDirectory = (path) => statSync(path).isDirectory() } = {}) {
+function ownedAvdDirectory(avdName, { env = ambientEnv(), home = (process.platform === "win32" ? env.USERPROFILE : env.HOME) || homedir(), readFile = (path) => readFileSync(path, "utf8"), realpath = realpathSync, isDirectory = (path) => statSync(path).isDirectory() } = {}) {
 	if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return null;
 	for (const root of avdLookupRoots(env, home)) {
 		let ini;
@@ -831,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";
@@ -911,16 +963,16 @@ async function resetAdoptedAvd(avdName, serial, keepPackage) {
 	let firstFailure;
 	let unavailableTarget = false;
 	const commandTimeout = (timeoutMs) => recoveryDeadline === void 0 ? timeoutMs : Math.max(1, Math.min(timeoutMs, recoveryDeadline - Date.now()));
-	const assertTarget = () => {
-		const resolved = resolveOwnedAvdSerial(avdName, { timeoutMs: commandTimeout(3e4) });
+	const assertTarget = async () => {
+		const resolved = await resolveOwnedAvdSerialAsync(avdName, { timeoutMs: commandTimeout(3e4) });
 		unavailableTarget = Boolean(resolved.notRunning);
 		if (resolved.serial !== serial) throw new Error(`AVD ${avdName} is no longer running on ${serial}.`);
 	};
 	for (;;) {
 		unavailableTarget = false;
 		try {
-			assertTarget();
-			const packages = exec.runFile("adb", [
+			await assertTarget();
+			const packages = (await exec.runFileAsync("adb", [
 				"-s",
 				serial,
 				"shell",
@@ -928,20 +980,20 @@ async function resetAdoptedAvd(avdName, serial, keepPackage) {
 				"list",
 				"packages",
 				"-3"
-			], { timeoutMs: commandTimeout(3e4) }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+			], { timeoutMs: commandTimeout(3e4) })).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
 				const match = /^package:([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+)$/.exec(line);
 				if (!match) throw new Error(`Could not read installed apps on ${avdName}: ${line}`);
 				return match[1];
 			});
 			for (const packageName of packages) {
-				assertTarget();
+				await assertTarget();
 				const args = packageName === keepPackage ? [
 					"shell",
 					"pm",
 					"clear",
 					packageName
 				] : ["uninstall", packageName];
-				const result = exec.runFile("adb", [
+				const result = await exec.runFileAsync("adb", [
 					"-s",
 					serial,
 					...args
@@ -974,8 +1026,8 @@ function parseDfAvailableBytes(text) {
 	const available = lines[1].split(/\s+/)[3];
 	return available && /^\d+$/.test(available) ? Number(available) * 1024 : null;
 }
-function androidDataFreeBytes(serial) {
-	return parseDfAvailableBytes(getExecutor().runFileQuiet("adb", [
+async function androidDataFreeBytes(serial) {
+	return parseDfAvailableBytes(await getExecutor().runFileQuietAsync("adb", [
 		"-s",
 		serial,
 		"shell",
@@ -984,8 +1036,8 @@ function androidDataFreeBytes(serial) {
 		"/data"
 	], { timeoutMs: 3e4 }));
 }
-function trimAndroidCaches(serial, desiredFreeBytes) {
-	getExecutor().runFile("adb", [
+async function trimAndroidCaches(serial, desiredFreeBytes) {
+	await getExecutor().runFileAsync("adb", [
 		"-s",
 		serial,
 		"shell",
@@ -1010,7 +1062,7 @@ const CRASH_REPORT_MODE_EMULATOR_VERSION = 37;
 * Where the emulator keeps crashpad's database on Windows: `AndroidEmulator\emu-crash-<version>.db`
 * under GetTempPath, which reads TMP before TEMP.
 */
-function emulatorCrashDatabases(env = process.env) {
+function emulatorCrashDatabases(env = ambientEnv()) {
 	const root = join$1(env.TMP || env.TEMP || tmpdir(), "AndroidEmulator");
 	try {
 		return readdirSync(root).filter((name) => /^emu-crash-.*\.db$/.test(name)).map((name) => join$1(root, name));
@@ -1039,9 +1091,9 @@ function suppressEmulatorCrashConsent({ platform = process.platform, version = e
 	} catch {}
 	return [];
 }
-function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process.platform, openViewer = true } = {}) {
+async function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process.platform, openViewer = true } = {}) {
 	const exec = getExecutor();
-	const app = configuredAndroidEmulatorApp(platform);
+	const app = await configuredAndroidEmulatorApp(platform, ambientEnv());
 	const child = exec.spawn(androidToolPath("emulator"), [
 		"-avd",
 		avdName,
@@ -1050,7 +1102,7 @@ function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process
 		"-grpc",
 		String(consolePort + 3e3),
 		"-grpc-use-token",
-		...headlessEmulatorArgs(process.env, platform, openViewer ? app : "stim-desktop"),
+		...headlessEmulatorArgs(ambientEnv(), platform, openViewer ? app : "stim-desktop"),
 		...suppressEmulatorCrashConsent({ platform })
 	], {
 		cwd: androidToolCwd(platform),
@@ -1059,7 +1111,7 @@ function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process
 	});
 	child?.unref?.();
 	const pid = child?.pid ?? null;
-	if (openViewer && pid !== null && platform === "darwin" && app === "stim-desktop") openEmulatorInStimDesktop(`emulator-${consolePort}`);
+	if (openViewer && pid !== null && platform === "darwin" && app === "stim-desktop") await openEmulatorInStimDesktop(`emulator-${consolePort}`);
 	return pid;
 }
 function emulatorStdio(logFile) {
@@ -1114,8 +1166,8 @@ function emulatorDiskSpaceRemedy(lines) {
 function emulatorFailureRemedy(lines) {
 	return emulatorDiskSpaceRemedy(lines) ?? "Fix what the emulator reported above, then run `stim android` again.";
 }
-function getprop(exec, serial, prop, timeoutMs) {
-	const out = exec.runFileQuiet(androidToolPath("adb"), [
+async function getprop(exec, serial, prop, timeoutMs) {
+	const out = await exec.runFileQuietAsync(androidToolPath("adb"), [
 		"-s",
 		serial,
 		"shell",
@@ -1130,8 +1182,8 @@ const PACKAGE_MANAGER_PROBE = [
 	"path",
 	"android"
 ];
-function packageManagerReady(exec, serial, timeoutMs) {
-	const out = exec.runFileQuiet(androidToolPath("adb"), [
+async function packageManagerReady(exec, serial, timeoutMs) {
+	const out = await exec.runFileQuietAsync(androidToolPath("adb"), [
 		"-s",
 		serial,
 		...PACKAGE_MANAGER_PROBE
@@ -1144,7 +1196,7 @@ async function waitForBoot(serial, timeoutMs = 6e4, { aborted = () => false, pol
 	let exited = false;
 	const probeTimeout = () => Math.max(1, Math.min(commandTimeoutMs ?? timeoutMs, timeoutMs - (Date.now() - start)));
 	while (Date.now() - start < timeoutMs) {
-		if ((getprop(exec, serial, "sys.boot_completed", probeTimeout()) === "1" || getprop(exec, serial, "dev.bootcomplete", probeTimeout()) === "1") && packageManagerReady(exec, serial, probeTimeout())) return { ok: true };
+		if ((await getprop(exec, serial, "sys.boot_completed", probeTimeout()) === "1" || await getprop(exec, serial, "dev.bootcomplete", probeTimeout()) === "1") && await packageManagerReady(exec, serial, probeTimeout())) return { ok: true };
 		if (aborted()) {
 			exited = true;
 			break;
@@ -1152,39 +1204,39 @@ async function waitForBoot(serial, timeoutMs = 6e4, { aborted = () => false, pol
 		await new Promise((r) => setTimeout(r, commandTimeoutMs === void 0 ? pollMs : Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start)))));
 	}
 	const diagnosticDeadline = Date.now() + Math.min(commandTimeoutMs ?? 5e3, 5e3);
-	const diagnosticQuery = (args) => {
+	const diagnosticQuery = async (args) => {
 		const remaining = diagnosticDeadline - Date.now();
 		if (remaining <= 0) return "";
-		const value = exec.runFileQuiet(androidToolPath("adb"), args, { timeoutMs: remaining });
+		const value = await exec.runFileQuietAsync(androidToolPath("adb"), args, { timeoutMs: remaining });
 		return typeof value === "string" ? value.trim() : "";
 	};
 	return {
 		ok: false,
 		...exited ? { exited: true } : {},
 		diagnostic: {
-			devices: diagnosticQuery(["devices"]),
-			sysBoot: diagnosticQuery([
+			devices: await diagnosticQuery(["devices"]),
+			sysBoot: await diagnosticQuery([
 				"-s",
 				serial,
 				"shell",
 				"getprop",
 				"sys.boot_completed"
 			]),
-			devBoot: diagnosticQuery([
+			devBoot: await diagnosticQuery([
 				"-s",
 				serial,
 				"shell",
 				"getprop",
 				"dev.bootcomplete"
 			]),
-			bootAnim: diagnosticQuery([
+			bootAnim: await diagnosticQuery([
 				"-s",
 				serial,
 				"shell",
 				"getprop",
 				"init.svc.bootanim"
 			]),
-			packageManager: diagnosticQuery([
+			packageManager: await diagnosticQuery([
 				"-s",
 				serial,
 				...PACKAGE_MANAGER_PROBE
@@ -1194,24 +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;
-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 (exec.runFileQuiet(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) }) === null) console.error(`warning: could not flush ${serial} before shutdown; shutting it down anyway`);
-	exec.runFileQuiet(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)) });
-}
-function sleepSync(ms) {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	], 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"] : []));
@@ -1263,6 +1333,18 @@ function listAvdEmulatorProcesses(avdName, platform) {
 	], { timeoutMs: 5e3 });
 	return out === null ? null : parseAvdEmulatorProcesses(out, avdName);
 }
+async function listAvdEmulatorProcessesAsync(avdName, platform, operation) {
+	if (platform === "win32") return [];
+	const out = await runOperationFileQuiet(operation, getExecutor(), "ps", [
+		"-axww",
+		"-o",
+		"pid=,command="
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	});
+	return out === null ? null : parseAvdEmulatorProcesses(out, avdName);
+}
 function scanAvdEmulatorProcesses(avdName, platform, listProcesses) {
 	const pids = listProcesses(avdName, platform);
 	if (pids === null) throw new Error(`Could not read the process table to verify that owned AVD ${avdName} stopped.`);
@@ -1285,19 +1367,44 @@ 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
 */
-function emulatorCrashHandlerPids(qemuPid) {
-	const out = getExecutor().runFileQuiet("powershell.exe", [
+async function emulatorCrashHandlerPids(qemuPid, operation) {
+	const out = await runOperationFileQuiet(operation, getExecutor(), "powershell.exe", [
 		"-NoProfile",
 		"-NonInteractive",
 		"-Command",
 		`Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'crashpad_handler.exe' -and $_.ParentProcessId -eq ${qemuPid} } | ForEach-Object ProcessId`
-	], { timeoutMs: 1e4 });
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	});
 	return String(out ?? "").split(/\r?\n/).map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid > 0);
 }
 const EMULATOR_SIGNAL_GRACE_MS = 5e3;
@@ -1308,14 +1415,31 @@ 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.
 */
-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 = listAvdEmulatorProcesses, captureIdentity = process_identity_exports.captureProcessIdentity, inspectIdentity = process_identity_exports.inspectProcessIdentity, signal = (pid, name) => signalProcessTree(pid, name, { platform }), directoryExists = (path) => statSync(path).isDirectory(), crashHandlerPids = emulatorCrashHandlerPids, killCrashHandler = (pid) => signalProcessTree(pid, "SIGKILL", { platform }), now = Date.now, sleep = sleepSync } = {}) {
+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;
+	};
 	const identities = /* @__PURE__ */ new Map();
-	for (const pid of scanAvdEmulatorProcesses(avdName, platform, listProcesses)) {
+	for (const pid of await scan()) {
 		const captured = captureIdentity(pid);
 		identities.set(pid, captured.ok ? {
 			pid,
@@ -1337,35 +1461,40 @@ function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID
 		if (processId !== null && !identities.has(processId) && processAlive(processId)) pids.push(processId);
 		return pids;
 	};
-	const waitUntil = (until) => {
+	const waitUntil = async (until) => {
 		for (;;) {
+			operation?.signal.throwIfAborted();
 			if (running().length === 0) return true;
 			const remaining = until - now();
 			if (remaining <= 0) return false;
-			sleep(Math.min(pollMs, remaining));
+			await sleep(Math.min(pollMs, remaining));
 		}
 	};
 	const started = now();
 	if (shutdown) {
 		const deadline = started + timeoutMs;
 		const shutdownTimeoutMs = deadline - now();
-		if (shutdownTimeoutMs > 0) shutdown(shutdownTimeoutMs);
-		waitUntil(deadline);
+		if (shutdownTimeoutMs > 0) await shutdown(shutdownTimeoutMs);
+		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 {
-			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 (waitUntil(now() + graceMs)) break;
+		if (await waitUntil(now() + graceMs)) break;
 	}
 	const left = new Set(running());
-	for (const pid of scanAvdEmulatorProcesses(avdName, platform, listProcesses)) {
+	for (const pid of await scan()) {
 		const record = identities.get(pid);
 		if (record === void 0 || (record === null ? processAlive(pid) : inspectIdentity(record) !== "gone")) left.add(pid);
 	}
@@ -1380,10 +1509,14 @@ function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID
 	}
 	if (platform === "win32" && processId !== null) {
 		const handlerDeadline = now() + CRASH_HANDLER_EXIT_TIMEOUT_MS;
-		for (const handler of crashHandlerPids(processId)) {
-			while (processAlive(handler) && now() < handlerDeadline) sleep(pollMs);
+		for (const handler of await crashHandlerPids(processId)) {
+			while (processAlive(handler) && now() < handlerDeadline) {
+				operation?.signal.throwIfAborted();
+				await sleep(pollMs);
+			}
+			operation?.signal.throwIfAborted();
 			if (processAlive(handler)) {
-				killCrashHandler(handler);
+				await killCrashHandler(handler);
 				if (processAlive(handler)) throw new Error(`Crashpad handler ${handler} for owned AVD ${avdName} stayed alive.`);
 			}
 		}
@@ -1405,8 +1538,58 @@ function getAvdNameForSerial(serial, { timeoutMs = EMU_AVD_NAME_TIMEOUT_MS } = {
 	if (!out) return null;
 	return out.split("\n")[0]?.trim() || null;
 }
-function resolveOwnedAvdSerial(avdName, opts = {}) {
-	return ownedAvdSerialResolver(opts)(avdName);
+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",
+		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;
+}
+/** `resolveOwnedAvdSerial` without blocking the event loop, with the same reads and the same timeout budget. */
+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, signal, operation } = {}) {
+	const started = Date.now();
+	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();
+	const avdNameOf = (serial) => {
+		let name = names.get(serial);
+		if (!name) {
+			name = getAvdNameForSerialAsync(serial, remaining());
+			names.set(serial, name);
+		}
+		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 };
+	};
 }
 function once(read) {
 	let result;
@@ -1448,4 +1631,4 @@ function ownedAvdSerialResolver({ timeoutMs } = {}) {
 	};
 }
 //#endregion
-export { trimAndroidCaches as $, listAvds as A, ownedAvdSystemImage as B, emulatorFailureRemedy as C, hostSystemImageArch as D, getAvdNameForSerial as E, ownedAvdDeviceProfile as F, probeEmulatorSerial as G, parseAvdSystemImage as H, ownedAvdDirectory as I, resolveOwnedAvdSerial as J, profileNeedsFoldFeature as K, ownedAvdMatchesConfiguration as L, listOrphanedAvdDirectories as M, memoizeEmulatorProbe as N, listAdbDevices as O, nextConsolePort as P, systemImageSupportsFold as Q, ownedAvdName as R, emulatorDiskSpaceRemedy as S, findBuildTool as T, physicalDeviceModel as U, parseAvdDeviceProfile as V, pickDefaultSystemImage as W, shutdownAndroidEmulator as X, resolvePhysicalDevice as Y, sleepSync as Z, avdStorageRoots as _, androidDeviceAbi as a, POOL_SETTING_REMEDY as at, createOwnedAvd as b, androidPoolNoCandidatesRefusal as c, eraseParkedAfter as ct, androidToolPath as d, parkedMaxSetting as dt, waitForAndroidEmulatorShutdown as et, assertOwnedAvdStopped as f, readParked as ft, avdPoolConfiguration as g, avdPathExists as h, configuredAndroidEmulatorApp as ht, androidDataFreeBytes as i, isStimOwnedSim as it, listInstalledSystemImages as j, listAvdDeviceProfiles as k, androidSystemImageAbi as l, isLegacyDeletionClaim as lt, avdNameAbsent as m, selectParked as mt, OWNED_AVD_CONFIG_DEFAULTS as n, wipeAvdUserData as nt, androidHome as o, adoptParked as ot, avdIniPaths as p, removeParkedAfter as pt, resetAdoptedAvd as q, androidBuildToolName as r, isStimOwnedAvd as rt, androidPoolCandidates as s, dropParked as st, DEFAULT_AVD_DEVICE_PROFILE as t, waitForBoot as tt, androidToolCwd as u, parkSim as ut, bootAndroidEmulator as v, extractEmulatorFailure as w, deleteAvd as x, configureNewOwnedAvd as y, ownedAvdSerialResolver 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 };