stim 1.1.0 → 1.3.0

package/dist/android-xmyGBNy5.mjs

@@ -1,665 +0,0 @@
-import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
-import { r as pidExists } from "./metro-B01H3EuD.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-BSwrY4FZ.mjs";
-import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, isAbsolute, join, resolve } from "path";
-//#region src/sim/android.ts
-const ANDROID_ABIS = /* @__PURE__ */ new Set([
-	"armeabi-v7a",
-	"arm64-v8a",
-	"x86",
-	"x86_64"
-]);
-function androidHome() {
-	return process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || join(homedir(), "Library", "Android", "sdk");
-}
-const SDK_TOOL_LOCATIONS = {
-	emulator: ["emulator", "emulator"],
-	adb: ["platform-tools", "adb"],
-	avdmanager: [
-		"cmdline-tools",
-		"latest",
-		"bin",
-		"avdmanager"
-	]
-};
-function androidToolPath(tool) {
-	const abs = join(androidHome(), ...SDK_TOOL_LOCATIONS[tool]);
-	return existsSync(abs) ? abs : tool;
-}
-function newestBuildTools(names) {
-	return [...Array.isArray(names) ? names : []].filter((n) => /^\d+(\.\d+)*(-\w+)?$/.test(String(n))).toSorted((a, b) => {
-		const pa = String(a).split(/[.-]/).map(Number);
-		const pb = String(b).split(/[.-]/).map(Number);
-		for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-			const d = (pb[i] || 0) - (pa[i] || 0);
-			if (d) return d;
-		}
-		return 0;
-	})[0] ?? null;
-}
-function buildToolsMajor(version) {
-	const major = Number(String(version ?? "").split(/[.-]/)[0]);
-	return Number.isFinite(major) ? major : 0;
-}
-function findBuildTool(tools, { home = androidHome(), readDir = readdirSync, exists = existsSync } = {}) {
-	const root = join(home, "build-tools");
-	let versions = [];
-	try {
-		versions = readDir(root);
-	} catch {
-		return null;
-	}
-	while (versions.length) {
-		const version = newestBuildTools(versions);
-		if (!version) return null;
-		for (const tool of tools) {
-			const path = join(root, version, tool);
-			if (exists(path)) return {
-				path,
-				tool,
-				version,
-				major: buildToolsMajor(version)
-			};
-		}
-		versions = versions.filter((v) => v !== version);
-	}
-	return null;
-}
-function androidTool(tool) {
-	const resolved = androidToolPath(tool);
-	return resolved === tool ? tool : `"${resolved}"`;
-}
-function listInstalledSystemImages() {
-	const root = join(androidHome(), "system-images");
-	const images = [];
-	if (!existsSync(root)) return images;
-	for (const apiDir of safeList(root)) {
-		const m = apiDir.match(/^android-(\d+)$/);
-		if (!m) continue;
-		const apiPath = join(root, apiDir);
-		for (const tag of safeList(apiPath)) for (const arch of safeList(join(apiPath, tag))) images.push({
-			api: Number(m[1]),
-			tag,
-			arch,
-			pkg: `system-images;${apiDir};${tag};${arch}`
-		});
-	}
-	return images;
-}
-function safeList(dir) {
-	try {
-		return readdirSync(dir);
-	} catch {
-		return [];
-	}
-}
-function pageSizeRank(image) {
-	return /(^|_)ps16k$/.test(String(image?.tag || "")) ? 1 : 0;
-}
-function hostSystemImageArch(arch = process.arch) {
-	return arch === "arm64" ? "arm64-v8a" : "x86_64";
-}
-function pickDefaultSystemImage(images, { systemImage, hostArch } = {}) {
-	if (systemImage) return images.find((i) => i.pkg === systemImage) || null;
-	const wanted = hostArch ?? hostSystemImageArch();
-	const matching = images.filter((i) => i.arch === wanted);
-	if (matching.length === 0) return null;
-	return matching.toSorted((a, b) => pageSizeRank(a) - pageSizeRank(b) || b.api - a.api || (b.tag === "google_apis" ? 1 : 0) - (a.tag === "google_apis" ? 1 : 0))[0] ?? null;
-}
-function createOwnedAvd(label, { systemImage } = {}) {
-	const pick = pickDefaultSystemImage(listInstalledSystemImages(), { systemImage });
-	if (!pick) {
-		const arch = hostSystemImageArch();
-		throw new Error(`No ${arch} Android system image is installed. Install one, e.g.: sdkmanager "system-images;android-36;google_apis;${arch}"`);
-	}
-	const avdName = ownedAvdName(label);
-	getExecutor().run(`echo no | ${androidTool("avdmanager")} create avd -n "${avdName}" -k "${pick.pkg}"`);
-	return {
-		avdName,
-		systemImage: pick.pkg
-	};
-}
-function parseAvdSystemImage(configIni) {
-	for (const line of String(configIni).split(/\r?\n/)) {
-		const separator = line.indexOf("=");
-		if (separator < 0) continue;
-		if (line.slice(0, separator).trim() !== "image.sysdir.1") continue;
-		const dir = line.slice(separator + 1).trim().replace(/\/+$/, "");
-		if (!dir) return null;
-		return dir.split("/").join(";");
-	}
-	return null;
-}
-function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8") } = {}) {
-	const directory = avdDirectory(avdName);
-	if (!directory) return null;
-	try {
-		return parseAvdSystemImage(readFile(join(directory, "config.ini")));
-	} catch {
-		return null;
-	}
-}
-function sanitizeAvdLabel(label) {
-	return String(label).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function ownedAvdName(label) {
-	const clean = sanitizeAvdLabel(label);
-	return `stim-${clean.startsWith("stim-") ? clean.slice(5) : clean}`;
-}
-function deleteAvd(avdName) {
-	if (!avdName?.startsWith("stim-")) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD (name must start with "stim-").`);
-	getExecutor().run(`${androidTool("avdmanager")} delete avd -n "${avdName}"`);
-}
-function parseAvdList(text) {
-	return text.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("INFO") && !l.startsWith("WARNING"));
-}
-function parseAdbDevices(text) {
-	const lines = text.split("\n").slice(1);
-	const emulators = [];
-	const physical = [];
-	const unhealthy = [];
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		const match = trimmed.match(/^(\S+)\s+(.+)$/);
-		if (!match) continue;
-		const serial = match[1];
-		const status = match[2].trim();
-		const m = serial.match(/^emulator-(\d+)$/);
-		if (m) {
-			const consolePort = parseInt(m[1], 10);
-			if (status === "device") emulators.push({
-				serial,
-				consolePort
-			});
-			else unhealthy.push({
-				serial,
-				kind: "emulator",
-				consolePort,
-				status
-			});
-		} else if (status === "device") physical.push({ serial });
-		else unhealthy.push({
-			serial,
-			kind: "physical",
-			status
-		});
-	}
-	return {
-		emulators,
-		physical,
-		unhealthy
-	};
-}
-function listAvds({ timeoutMs } = {}) {
-	return parseAvdList(getExecutor().run(`${androidTool("emulator")} -list-avds`, { timeoutMs }));
-}
-function listAdbDevices({ timeoutMs } = {}) {
-	return parseAdbDevices(getExecutor().run(`${androidTool("adb")} devices`, { timeoutMs }));
-}
-const ADB_PROP_TIMEOUT_MS = 5e3;
-const EMULATOR_HARDWARE = /* @__PURE__ */ new Set([
-	"ranchu",
-	"goldfish",
-	"vbox86",
-	"vbox86p"
-]);
-function adbProp(serial, name) {
-	try {
-		const out = getExecutor().runFile(androidToolPath("adb"), [
-			"-s",
-			serial,
-			"shell",
-			"getprop",
-			name
-		], { timeoutMs: ADB_PROP_TIMEOUT_MS });
-		return String(out ?? "").trim() || null;
-	} catch {
-		return null;
-	}
-}
-function physicalDeviceModel(serial) {
-	return adbProp(serial, "ro.product.model");
-}
-function androidDeviceAbi(serial) {
-	const abi = adbProp(serial, "ro.product.cpu.abi");
-	return abi && ANDROID_ABIS.has(abi) ? abi : null;
-}
-function androidSystemImageAbi(systemImage) {
-	const abi = String(systemImage ?? "").split(";").at(-1) ?? "";
-	return ANDROID_ABIS.has(abi) ? abi : null;
-}
-function looksLikeEmulator({ kernelQemu, hardware }) {
-	if (String(kernelQemu ?? "").trim() === "1") return true;
-	return EMULATOR_HARDWARE.has(String(hardware ?? "").trim().toLowerCase());
-}
-function probeEmulatorSerial(serial) {
-	return looksLikeEmulator({
-		kernelQemu: adbProp(serial, "ro.kernel.qemu"),
-		hardware: adbProp(serial, "ro.hardware")
-	});
-}
-function unreachableDeviceRefusal(entry) {
-	return {
-		error: `${entry.serial} is connected but ${entry.status}, so adb cannot talk to it.`,
-		remedy: entry.status === "unauthorized" ? "Unlock the device, accept the USB debugging prompt, then retry." : "Reconnect the device or run `adb reconnect`, then retry."
-	};
-}
-function emulatorRefusal(serial) {
-	return {
-		error: `${serial} is an emulator, not a physical device.`,
-		remedy: "Run `stim android` without --device to use this workspace's owned emulator."
-	};
-}
-function memoizeEmulatorProbe(probe = probeEmulatorSerial) {
-	const seen = /* @__PURE__ */ new Map();
-	return (serial) => {
-		const cached = seen.get(serial);
-		if (cached !== void 0) return cached;
-		const probed = probe(serial);
-		seen.set(serial, probed);
-		return probed;
-	};
-}
-function androidPoolCandidates(adb, isEmulator = probeEmulatorSerial) {
-	return (adb?.physical ?? []).filter((entry) => !isEmulator(entry.serial));
-}
-function androidPoolNoCandidatesRefusal(adb, isEmulator = probeEmulatorSerial) {
-	const physical = adb?.physical ?? [];
-	if (physical.length > 0 && physical.every((entry) => isEmulator(entry.serial))) {
-		const reasons = physical.map((entry) => emulatorRefusal(entry.serial));
-		return {
-			error: reasons.map((reason) => reason.error).join(" "),
-			remedy: [...new Set(reasons.map((reason) => reason.remedy))].join(" ")
-		};
-	}
-	return resolvePhysicalDevice(null, adb, isEmulator);
-}
-function resolvePhysicalDevice(requested, adb, isEmulator = probeEmulatorSerial) {
-	const physical = adb?.physical ?? [];
-	const unhealthy = adb?.unhealthy ?? [];
-	if (requested) {
-		if (physical.some((p) => p.serial === requested)) return isEmulator(requested) ? emulatorRefusal(requested) : { serial: requested };
-		if (/^emulator-\d+$/.test(requested)) return emulatorRefusal(requested);
-		const unreachable = unhealthy.find((u) => u.serial === requested);
-		if (unreachable) return unreachableDeviceRefusal(unreachable);
-		const connected = physical.map((p) => p.serial);
-		return {
-			error: connected.length ? `${requested} is not connected. adb reports these physical devices: ${connected.join(", ")}.` : `${requested} is not connected, and adb reports no physical device at all.`,
-			remedy: "Check the cable and `adb devices`, then retry with a serial adb lists."
-		};
-	}
-	if (physical.length === 1) {
-		const only = physical[0].serial;
-		return isEmulator(only) ? emulatorRefusal(only) : { serial: only };
-	}
-	if (physical.length > 1) return {
-		error: `Several physical devices are connected: ${physical.map((p) => p.serial).join(", ")}.`,
-		remedy: "Name the one to build for with `stim android --device <serial>`."
-	};
-	const unreachable = unhealthy.find((u) => u.kind === "physical");
-	if (unreachable) return unreachableDeviceRefusal(unreachable);
-	return {
-		error: "No physical Android device is connected.",
-		remedy: "Plug the device in, accept the USB debugging prompt, then check `adb devices`."
-	};
-}
-function nextConsolePort(claimedPorts) {
-	if (claimedPorts.length === 0) return 5554;
-	return Math.max(...claimedPorts) + 2;
-}
-function headlessEmulatorArgs(env = process.env, platform = process.platform) {
-	const args = [];
-	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");
-	return args;
-}
-function parseAvdRootIni(contents) {
-	let path = null;
-	let relativePath = null;
-	for (const rawLine of contents.split(/\r?\n/)) {
-		const line = rawLine.trim();
-		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
-		const separator = line.indexOf("=");
-		if (separator < 0) continue;
-		const key = line.slice(0, separator).trim();
-		const value = line.slice(separator + 1).trim();
-		if (!value) continue;
-		if (key === "path") path = value;
-		if (key === "path.rel") relativePath = value;
-	}
-	return {
-		path,
-		relativePath
-	};
-}
-function ownedAvdDirectory(avdName, { env = process.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;
-	const roots = [
-		env.ANDROID_AVD_HOME,
-		env.ANDROID_SDK_HOME ? join(env.ANDROID_SDK_HOME, "avd") : null,
-		join(home, ".android", "avd")
-	];
-	for (const root of new Set(roots.filter((value) => Boolean(value)))) {
-		let ini;
-		try {
-			ini = readFile(join(root, `${avdName}.ini`));
-		} catch (error) {
-			const code = error.code;
-			if (code === "ENOENT" || code === "ENOTDIR") continue;
-			return null;
-		}
-		const parsed = parseAvdRootIni(ini);
-		const candidates = [parsed.relativePath && !isAbsolute(parsed.relativePath) ? resolve(dirname(root), parsed.relativePath) : null, parsed.path && isAbsolute(parsed.path) ? parsed.path : null];
-		for (const candidate of candidates) {
-			if (!candidate) continue;
-			try {
-				const canonical = realpath(candidate);
-				if (isDirectory(canonical)) return canonical;
-			} catch {}
-		}
-		return null;
-	}
-	return null;
-}
-function withAvdConfigOverrides(contents, overrides) {
-	const newline = contents.includes("\r\n") ? "\r\n" : "\n";
-	const trailingNewline = /\r?\n$/.test(contents);
-	const lines = contents.split(/\r?\n/);
-	if (trailingNewline) lines.pop();
-	const updated = [];
-	const remaining = new Map(Object.entries(overrides));
-	for (const line of lines) {
-		const separator = line.indexOf("=");
-		const key = separator >= 0 ? line.slice(0, separator).trim() : "";
-		if (!remaining.has(key)) {
-			if (!Object.hasOwn(overrides, key)) updated.push(line);
-			continue;
-		}
-		updated.push(`${key}=${remaining.get(key)}`);
-		remaining.delete(key);
-	}
-	for (const [key, value] of remaining) updated.push(`${key}=${value}`);
-	return updated.join(newline) + (trailingNewline ? newline : "");
-}
-let avdConfigWriteSequence = 0;
-function configureNewOwnedAvd(avdName, { dataPartitionSizeGb, avdConfig = {} }, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8"), writeFile = (path, contents) => writeFileSync(path, contents, {
-	encoding: "utf8",
-	flag: "wx"
-}), rename = renameSync, remove = (path) => rmSync(path, { force: true }) } = {}) {
-	const sizeBytes = androidDataPartitionSizeBytes(dataPartitionSizeGb);
-	const directory = avdDirectory(avdName);
-	if (!directory) throw new Error(`Could not resolve the content directory for newly created AVD ${avdName}.`);
-	const configPath = join(directory, "config.ini");
-	const original = readFile(configPath);
-	const expected = {
-		...avdConfig,
-		"disk.dataPartition.size": String(sizeBytes)
-	};
-	const updated = withAvdConfigOverrides(original, expected);
-	const tempPath = join(directory, `.config.ini.stim-${process.pid}-${++avdConfigWriteSequence}.tmp`);
-	try {
-		writeFile(tempPath, updated);
-		rename(tempPath, configPath);
-	} catch (error) {
-		try {
-			remove(tempPath);
-		} catch {}
-		throw error;
-	}
-	const verified = readFile(configPath);
-	for (const [key, value] of Object.entries(expected)) if (!verified.split(/\r?\n/).includes(`${key}=${value}`)) throw new Error(`Could not verify ${key} in ${configPath}.`);
-	return configPath;
-}
-function avdPoolConfiguration(dataPartitionSizeGb, avdConfig) {
-	return JSON.stringify(Object.entries({
-		...avdConfig,
-		"disk.dataPartition.size": String(androidDataPartitionSizeBytes(dataPartitionSizeGb))
-	}).toSorted(([a], [b]) => a.localeCompare(b)));
-}
-function ownedAvdMatchesConfiguration(avdName, configuration) {
-	const directory = ownedAvdDirectory(avdName);
-	if (!directory) return false;
-	const contents = readFileSync(join(directory, "config.ini"), "utf8");
-	const expected = JSON.parse(configuration);
-	return Array.isArray(expected) && expected.length > 0 && expected.every((entry) => Array.isArray(entry) && entry.length === 2 && entry.every((value) => typeof value === "string") && contents.split(/\r?\n/).some((line) => line.trim() === `${entry[0]}=${entry[1]}`));
-}
-async function resetAdoptedAvd(avdName, serial, keepPackage) {
-	const exec = getExecutor();
-	let recoveryDeadline;
-	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) });
-		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", [
-				"-s",
-				serial,
-				"shell",
-				"pm",
-				"list",
-				"packages",
-				"-3"
-			], { 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();
-				const args = packageName === keepPackage ? [
-					"shell",
-					"pm",
-					"clear",
-					packageName
-				] : ["uninstall", packageName];
-				const result = exec.runFile("adb", [
-					"-s",
-					serial,
-					...args
-				], { timeoutMs: commandTimeout(12e4) });
-				if (result.trim() !== "Success") throw new Error(`Could not clean ${packageName} on ${avdName}: ${result.trim()}`);
-			}
-			return;
-		} catch (error) {
-			const failed = error;
-			const detail = [
-				failed?.message || String(error),
-				failed?.stderr,
-				failed?.stdout
-			].filter(Boolean).map(String).join("\n");
-			firstFailure ??= detail;
-			const diagnostic = detail === firstFailure ? detail : `${firstFailure}\nRecovery failed: ${detail}`;
-			const transient = /(?:^|\n)(?:adb: )?(?:error: )?(?:device offline|closed)\s*(?:$|\n)/i.test(detail);
-			recoveryDeadline ??= Date.now() + 3e4;
-			if (!unavailableTarget && !transient || Date.now() >= recoveryDeadline) throw new Error(diagnostic, { cause: error });
-			const delayMs = Math.min(1e3, recoveryDeadline - Date.now());
-			await new Promise((done) => setTimeout(done, delayMs));
-			const ready = await waitForBoot(serial, recoveryDeadline - Date.now(), { commandTimeoutMs: 5e3 });
-			if (!ready.ok) throw new Error(`${diagnostic}\nEmulator did not recover: ${JSON.stringify(ready.diagnostic)}`, { cause: error });
-		}
-	}
-}
-function bootAndroidEmulator(avdName, consolePort, { logFile } = {}) {
-	const child = getExecutor().spawn(androidToolPath("emulator"), [
-		"-avd",
-		avdName,
-		"-port",
-		String(consolePort),
-		...headlessEmulatorArgs()
-	], {
-		detached: true,
-		stdio: emulatorStdio(logFile)
-	});
-	child?.unref?.();
-	return child?.pid ?? null;
-}
-function emulatorStdio(logFile) {
-	if (!logFile) return "ignore";
-	try {
-		mkdirSync(dirname(logFile), { recursive: true });
-		const fd = openSync(logFile, "w");
-		return [
-			"ignore",
-			fd,
-			fd
-		];
-	} catch {
-		return "ignore";
-	}
-}
-const EMULATOR_PIPE_SEVERITY = /^(?:\S+:\s+)?(FATAL|ERROR)\s*\|\s*\S/;
-const EMULATOR_PANIC = /^(?:\S+:\s+)?PANIC:\s*\S/;
-function extractEmulatorFailure(text) {
-	if (typeof text !== "string" || text.trim() === "") return [];
-	const matched = [];
-	const lines = text.split("\n");
-	for (let i = 0; i < lines.length; i++) {
-		const line = String(lines[i] ?? "").replace(/\r/g, "").trim();
-		if (!line) continue;
-		const pipe = EMULATOR_PIPE_SEVERITY.exec(line);
-		if (pipe) {
-			matched.push({
-				line,
-				fatal: pipe[1] !== "ERROR",
-				index: i
-			});
-			continue;
-		}
-		if (EMULATOR_PANIC.test(line)) matched.push({
-			line,
-			fatal: true,
-			index: i
-		});
-	}
-	const fatal = matched.filter((m) => m.fatal);
-	const pool = fatal.length > 0 ? fatal : matched;
-	const byText = /* @__PURE__ */ new Map();
-	for (const entry of pool) byText.set(entry.line.replace(/\s+/g, " ").toLowerCase(), entry);
-	return [...byText.values()].toSorted((a, b) => a.index - b.index).slice(-3).map((entry) => entry.line);
-}
-function emulatorDiskSpaceRemedy(lines) {
-	const text = (Array.isArray(lines) ? lines : []).join("\n");
-	if (!/ENOSPC|not enough space|no space left|disk (?:is )?full/i.test(text)) return null;
-	return "Free disk space (owned AVDs normally live under ~/.android/avd and can use several GB), then run `stim android` again.";
-}
-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.runQuiet(`${androidTool("adb")} -s ${serial} shell getprop ${prop}`, { timeoutMs });
-	return typeof out === "string" ? out.trim() : "";
-}
-async function waitForBoot(serial, timeoutMs = 6e4, { aborted = () => false, pollMs = 1e3, commandTimeoutMs } = {}) {
-	const exec = getExecutor();
-	const start = Date.now();
-	let exited = false;
-	const probeTimeout = () => commandTimeoutMs === void 0 ? void 0 : Math.max(1, Math.min(commandTimeoutMs, timeoutMs - (Date.now() - start)));
-	while (Date.now() - start < timeoutMs) {
-		if (getprop(exec, serial, "sys.boot_completed", probeTimeout()) === "1") return { ok: true };
-		if (getprop(exec, serial, "dev.bootcomplete", probeTimeout()) === "1") return { ok: true };
-		if (aborted()) {
-			exited = true;
-			break;
-		}
-		await new Promise((r) => setTimeout(r, commandTimeoutMs === void 0 ? pollMs : Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start)))));
-	}
-	const devicesOut = exec.runQuiet(`${androidTool("adb")} devices`, { timeoutMs: probeTimeout() });
-	return {
-		ok: false,
-		...exited ? { exited: true } : {},
-		diagnostic: {
-			devices: typeof devicesOut === "string" ? devicesOut.trim() : "",
-			sysBoot: getprop(exec, serial, "sys.boot_completed", probeTimeout()),
-			devBoot: getprop(exec, serial, "dev.bootcomplete", probeTimeout()),
-			bootAnim: getprop(exec, serial, "init.svc.bootanim", probeTimeout())
-		}
-	};
-}
-const ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS = 6e4;
-const ANDROID_EMULATOR_SHUTDOWN_POLL_MS = 100;
-function shutdownAndroidEmulator(serial, timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS) {
-	const exec = getExecutor();
-	const started = Date.now();
-	if (exec.runQuiet(`${androidTool("adb")} -s ${serial} shell sync`, { timeoutMs: Math.min(5e3, timeoutMs) }) === null) console.error(`warning: could not flush ${serial} before shutdown; shutting it down anyway`);
-	exec.runQuiet(`${androidTool("adb")} -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);
-}
-function avdProcessLockPaths(avdDirectory, platform) {
-	return ["hardware-qemu.ini.lock", "userdata-qemu.img.lock"].map((name) => join(avdDirectory, name, ...platform === "win32" ? ["pid"] : []));
-}
-function readAvdProcessId(path) {
-	try {
-		const pid = Number(readFileSync(path, "utf8").split("\0")[0]);
-		if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error(`Could not read the emulator PID from process lock ${path}.`);
-		return pid;
-	} catch (error) {
-		const code = error.code;
-		if (code === "ENOENT" || code === "ENOTDIR") return null;
-		throw error;
-	}
-}
-function resolveAvdProcess(avdName, { platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId } = {}) {
-	const directory = resolveDirectory(avdName);
-	if (!directory) throw new Error(`Could not resolve the content directory for owned AVD ${avdName}.`);
-	for (const lockPath of avdProcessLockPaths(directory, platform)) {
-		const processId = readProcessId(lockPath);
-		if (processId !== null) return {
-			directory,
-			processId
-		};
-	}
-	return {
-		directory,
-		processId: null
-	};
-}
-function assertOwnedAvdStopped(avdName, { processAlive = pidExists, ...resolveOptions } = {}) {
-	const { processId } = resolveAvdProcess(avdName, resolveOptions);
-	if (processId !== null && processAlive(processId)) throw new Error(`Owned AVD ${avdName} still has a live emulator process (${processId}).`);
-}
-function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, pollMs = ANDROID_EMULATOR_SHUTDOWN_POLL_MS, platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId, processAlive = pidExists, directoryExists = (path) => statSync(path).isDirectory(), now = Date.now, sleep = sleepSync } = {}) {
-	const { directory, processId } = resolveAvdProcess(avdName, {
-		platform,
-		resolveDirectory,
-		readProcessId
-	});
-	if (processId === null) throw new Error(`Could not find the emulator process lock for owned AVD ${avdName}.`);
-	const deadline = now() + timeoutMs;
-	const shutdownTimeoutMs = deadline - now();
-	if (shutdownTimeoutMs <= 0) throw new Error(`Owned AVD ${avdName} did not finish shutting down within ${Math.ceil(timeoutMs / 1e3)}s.`);
-	shutdown(shutdownTimeoutMs);
-	while (processAlive(processId)) {
-		const remaining = deadline - now();
-		if (remaining <= 0) throw new Error(`Owned AVD ${avdName} did not finish shutting down within ${Math.ceil(timeoutMs / 1e3)}s.`);
-		sleep(Math.min(pollMs, remaining));
-	}
-	if (!directoryExists(directory)) throw new Error(`Could not verify the content directory for owned AVD ${avdName} after shutdown.`);
-}
-function getAvdNameForSerial(serial, { timeoutMs } = {}) {
-	const out = getExecutor().runQuiet(`${androidTool("adb")} -s ${serial} emu avd name`, { timeoutMs });
-	if (!out) return null;
-	return out.split("\n")[0]?.trim() || null;
-}
-function resolveOwnedAvdSerial(avdName, { timeoutMs } = {}) {
-	const started = Date.now();
-	const remaining = () => ({ timeoutMs: timeoutMs === void 0 ? void 0 : Math.max(1, timeoutMs - (Date.now() - started)) });
-	if (!listAvds(remaining()).includes(avdName)) return { missing: true };
-	if (!avdName?.startsWith("stim-")) return { notOwned: true };
-	const adb = listAdbDevices(remaining());
-	const match = [...adb.emulators, ...adb.unhealthy.filter((entry) => entry.kind === "emulator" && entry.consolePort !== void 0)].find((e) => getAvdNameForSerial(e.serial, remaining()) === avdName);
-	if (match) return { serial: match.serial };
-	return { notRunning: true };
-}
-//#endregion
-export { resolveOwnedAvdSerial as A, ownedAvdMatchesConfiguration as C, pickDefaultSystemImage as D, physicalDeviceModel as E, shutdownAndroidEmulator as M, waitForAndroidEmulatorShutdown as N, probeEmulatorSerial as O, waitForBoot as P, ownedAvdDirectory as S, ownedAvdSystemImage as T, listAdbDevices as _, androidSystemImageAbi as a, memoizeEmulatorProbe as b, bootAndroidEmulator as c, deleteAvd as d, emulatorDiskSpaceRemedy as f, getAvdNameForSerial as g, findBuildTool as h, androidPoolNoCandidatesRefusal as i, resolvePhysicalDevice as j, resetAdoptedAvd as k, configureNewOwnedAvd as l, extractEmulatorFailure as m, androidHome as n, assertOwnedAvdStopped as o, emulatorFailureRemedy as p, androidPoolCandidates as r, avdPoolConfiguration as s, androidDeviceAbi as t, createOwnedAvd as u, listAvds as v, ownedAvdName as w, nextConsolePort as x, listInstalledSystemImages as y };