stim 1.2.0 → 1.3.1

package/dist/android-K63_0UfF.mjs

@@ -1,727 +0,0 @@
-import { t as getExecutor } from "./exec-CyylIdq9.mjs";
-import { r as pidExists } from "./metro-COslRK_F.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-DwU1_U_q.mjs";
-import { existsSync, lstatSync, 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"
-]);
-const DEFAULT_AVD_DEVICE = "pixel_6";
-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}" --device "${DEFAULT_AVD_DEVICE}"`);
-	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 avdIniPaths(root, ini) {
-	const parsed = parseAvdRootIni(ini);
-	return [parsed.relativePath && !isAbsolute(parsed.relativePath) ? resolve(dirname(root), parsed.relativePath) : null, parsed.path && isAbsolute(parsed.path) ? parsed.path : null].filter((candidate) => candidate !== null);
-}
-function avdStorageRoots() {
-	const env = process.env;
-	return [...new Set([
-		env.ANDROID_AVD_HOME,
-		env.ANDROID_EMULATOR_HOME ? join(env.ANDROID_EMULATOR_HOME, "avd") : null,
-		env.ANDROID_USER_HOME ? join(env.ANDROID_USER_HOME, "avd") : null,
-		env.ANDROID_SDK_HOME ? join(env.ANDROID_SDK_HOME, ".android", "avd") : null,
-		env.ANDROID_SDK_HOME ? join(env.ANDROID_SDK_HOME, "avd") : null,
-		join(homedir(), ".android", "avd")
-	].filter((value) => Boolean(value)))];
-}
-function avdPathExists(path) {
-	try {
-		lstatSync(path);
-		return true;
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-}
-function listOrphanedAvdDirectories(avdName) {
-	const roots = avdStorageRoots();
-	const stores = roots.filter(avdPathExists).map((root) => ({
-		root,
-		canonicalRoot: realpathSync(root),
-		names: readdirSync(root)
-	}));
-	const registered = /* @__PURE__ */ new Set();
-	for (const { root, canonicalRoot, names } of stores) for (const name of names.filter((entry) => entry.endsWith(".ini"))) {
-		const path = join(root, name);
-		const ini = readFileSync(path, "utf8");
-		const targets = /* @__PURE__ */ new Set([...avdIniPaths(root, ini), ...avdIniPaths(canonicalRoot, ini)]);
-		if (!targets.size) throw new Error(`Cannot verify AVD registration at ${path}; its data was kept.`);
-		for (const target of targets) try {
-			registered.add(realpathSync(target));
-		} catch (error) {
-			const code = error.code;
-			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
-		}
-	}
-	const orphaned = [];
-	for (const { canonicalRoot, names: entries } of stores) {
-		const names = avdName ? [`${avdName}.avd`] : entries;
-		for (const entry of names) {
-			if (!/^stim-[A-Za-z0-9._-]+\.avd$/.test(entry)) continue;
-			const name = entry.slice(0, -4);
-			if (roots.some((candidate) => avdPathExists(join(candidate, `${name}.ini`)))) continue;
-			const directory = join(canonicalRoot, entry);
-			if (registered.has(directory) || !avdPathExists(directory)) continue;
-			const stat = lstatSync(directory);
-			if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(directory) !== directory) throw new Error(`Cannot verify AVD data at ${directory}; it was kept.`);
-			if (!orphaned.some((candidate) => candidate.directory === directory)) orphaned.push({
-				name,
-				directory,
-				dev: stat.dev,
-				ino: stat.ino
-			});
-		}
-	}
-	return orphaned;
-}
-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;
-		}
-		for (const candidate of avdIniPaths(root, ini)) 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,
-		"hw.device.name": DEFAULT_AVD_DEVICE,
-		"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 { pickDefaultSystemImage as A, memoizeEmulatorProbe as C, ownedAvdName as D, ownedAvdMatchesConfiguration as E, shutdownAndroidEmulator as F, waitForAndroidEmulatorShutdown as I, waitForBoot as L, resetAdoptedAvd as M, resolveOwnedAvdSerial as N, ownedAvdSystemImage as O, resolvePhysicalDevice as P, listOrphanedAvdDirectories as S, ownedAvdDirectory as T, findBuildTool as _, androidSystemImageAbi as a, listAvds as b, avdPoolConfiguration as c, configureNewOwnedAvd as d, createOwnedAvd as f, extractEmulatorFailure as g, emulatorFailureRemedy as h, androidPoolNoCandidatesRefusal as i, probeEmulatorSerial as j, physicalDeviceModel as k, avdStorageRoots as l, emulatorDiskSpaceRemedy as m, androidHome as n, assertOwnedAvdStopped as o, deleteAvd as p, androidPoolCandidates as r, avdPathExists as s, androidDeviceAbi as t, bootAndroidEmulator as u, getAvdNameForSerial as v, nextConsolePort as w, listInstalledSystemImages as x, listAdbDevices as y };