stim 1.12.0 → 1.13.0

package/dist/{android-75Sk2rIR.mjs → android-qx_31wJo.mjs}

@@ -1,13 +1,15 @@
-import { _ as loadConfig$1, d as getConfigDir } from "./config-0jCcMM0E.mjs";
+import { A as ownership_claim_exports, B as deviceSlotPlatforms, E as withConfigLock$1, L as assignSlotDevice, O as process_identity_exports, S as saveConfig, U as projectDeviceSlots, W as removeSlotDevice, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1 } from "./config-0jCcMM0E.mjs";
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { P as withDirLock, c as signalProcessTree, i as pidExists } from "./metro-Dzo30hvJ.mjs";
-import { n as stimDesktopInstalled, t as settingDefault } from "./stim-desktop-D0xhpZt8.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-BlyDn2Oz.mjs";
-import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { existsSync as existsSync$1, lstatSync as lstatSync$1, mkdirSync as mkdirSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { a as pidExists, l as signalProcessTree } from "./metro-BPeY1YMh.mjs";
+import { n as settingDefault, r as stimDesktopInstalled, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-CXt8-Z3J.mjs";
+import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-Cd558h31.mjs";
+import { c as androidDataPartitionSizeBytes } from "./settings-xB0Frkg6.mjs";
+import { existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
 import { dirname, isAbsolute, join, resolve } from "path";
-import { ANDROID_EMULATOR_APPS, createdDevicesFile, createdDevicesLock, readCreatedDevices, readCreatedDevices as readCreatedDevices$1, settingDefinition } from "@stim-cli/core/state";
+import { ANDROID_EMULATOR_APPS, loadConfig, settingDefinition } from "@stim-cli/core/state";
+import { join as join$1 } from "node:path";
 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;
@@ -22,66 +24,232 @@ function openEmulatorInStimDesktop(serial) {
 		"-a",
 		"Stim",
 		`stim-desktop://open?serial=${serial}`
-	], {
-		timeoutMs: 5e3,
-		killSignal: "SIGKILL"
+	], STIM_DESKTOP_OPEN_OPTIONS);
+}
+const POOL_SETTING_REMEDY = "Run `stim guide settings` for the device pool bounds and where it can be set.";
+const MAX_SETTING = {
+	ios: {
+		key: "iosParkedMax",
+		env: "STIM_POOL_IOS_PARKED_MAX"
+	},
+	android: {
+		key: "androidParkedMax",
+		env: "STIM_POOL_ANDROID_PARKED_MAX"
+	}
+};
+function parseMax(raw, strings) {
+	const value = strings && typeof raw === "string" ? /^\d+$/.test(raw.trim()) ? Number(raw.trim()) : NaN : raw;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) return null;
+	return value;
+}
+function parkedMaxSetting(platform, { config, env = process.env } = {}) {
+	const { key, env: envKey } = MAX_SETTING[platform];
+	const fromEnv = env[envKey];
+	const explicit = fromEnv !== void 0 && fromEnv !== "";
+	const pool = (config === void 0 ? loadConfig$1() : config)?.pool;
+	if (!explicit && pool !== void 0 && (pool === null || typeof pool !== "object" || Array.isArray(pool))) return {
+		max: 0,
+		error: "Invalid pool value. Expected an object with simulator and emulator bounds."
+	};
+	const fromConfig = pool !== null && typeof pool === "object" && !Array.isArray(pool) ? pool[key] : void 0;
+	const raw = explicit ? fromEnv : fromConfig;
+	if (raw === void 0) return {
+		max: env.STIM_HOME ? 0 : 3,
+		error: null
+	};
+	const parsed = parseMax(raw, explicit);
+	if (parsed === null) return {
+		max: 0,
+		error: `Invalid ${explicit ? envKey : `pool.${key}`} value ${JSON.stringify(raw)}. Expected a whole number of parked ${platform === "ios" ? "simulators" : "emulators"}, 0 or more.`
+	};
+	return {
+		max: explicit ? parsed : env.STIM_HOME ? 0 : parsed,
+		error: null
+	};
+}
+function isParkedRecord(value, platform) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	return typeof record.udid === "string" && typeof record.name === "string" && record.name.startsWith("stim-") && typeof record.parkedAt === "string" && (platform === "android" ? record.udid === record.name && /^stim-[A-Za-z0-9._-]+$/.test(record.name) && typeof record.systemImage === "string" && typeof record.configuration === "string" : typeof record.deviceTypeIdentifier === "string" && typeof record.runtimeIdentifier === "string" && typeof record.simslimManaged === "boolean" && (record.bundleId === void 0 || typeof record.bundleId === "string") && (record.cacheKey === void 0 || typeof record.cacheKey === "string"));
+}
+function poolBlock(config) {
+	const raw = config?.parked;
+	const block = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+	const read = (platform) => {
+		const list = block[platform];
+		return Array.isArray(list) ? list.filter((record) => isParkedRecord(record, platform)) : [];
+	};
+	return {
+		ios: read("ios"),
+		android: read("android")
+	};
+}
+function readParked(platform, { config } = {}) {
+	return poolBlock(config === void 0 ? loadConfig$1() : config)[platform];
+}
+function writeParked(config, platform, records) {
+	config.parked = {
+		...poolBlock(config),
+		[platform]: records
+	};
+}
+function oldestFirst(records) {
+	return records.toSorted((a, b) => String(a.parkedAt).localeCompare(String(b.parkedAt)));
+}
+function isLegacyDeletionClaim(value) {
+	if (value === void 0) return false;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return true;
+	const marker = value;
+	return marker.kind !== "ownership-claim" || typeof marker.claimId !== "string" || marker.claimId.length === 0;
+}
+function selectParked(records, { deviceTypeIdentifier, runtimeIdentifier }) {
+	return oldestFirst(records.filter((r) => !isLegacyDeletionClaim(r.deletionClaim) && r.deviceTypeIdentifier === deviceTypeIdentifier && r.runtimeIdentifier === runtimeIdentifier));
+}
+function evictOverflow(records, max) {
+	if (records.length <= max) return {
+		keep: [...records],
+		evicted: []
+	};
+	const ordered = oldestFirst(records);
+	const evicted = ordered.slice(0, ordered.length - max);
+	const dropped = new Set(evicted.map((r) => r.udid));
+	return {
+		keep: records.filter((r) => !dropped.has(r.udid)),
+		evicted
+	};
+}
+function parkSim({ platform, projectPath, slot = "default", record, max }) {
+	return withConfigLock$1(() => {
+		const cfg = ensureConfig();
+		const current = deviceSlotPlatforms(cfg.projects[projectPath], slot)?.[platform];
+		const currentId = platform === "ios" ? current?.deviceUdid : current?.avdName;
+		if (!current?.owned || currentId !== record.udid) throw new Error(`The ${platform === "ios" ? "simulator" : "emulator"} assignment changed before parking.`);
+		const { keep, evicted } = evictOverflow([...readParked(platform, { config: cfg }).filter((r) => r.udid !== record.udid), record], max);
+		writeParked(cfg, platform, [...keep, ...evicted]);
+		const project = cfg.projects[projectPath];
+		if (project) removeSlotDevice(project, platform, slot);
+		saveConfig(cfg);
+		return evicted;
 	});
 }
-//#endregion
-//#region src/devices/created-devices.ts
-function update(platform, change) {
-	const dir = getConfigDir();
-	withDirLock(createdDevicesLock(), () => {
-		const current = readCreatedDevices();
-		const entries = new Set(current[platform]);
-		if (!change(entries)) return;
-		const next = {
-			version: 1,
-			ios: [...current.ios],
-			android: [...current.android],
-			[platform]: [...entries]
-		};
-		const file = createdDevicesFile();
-		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`);
+function adoptParked({ platform, projectPath, slot = "default", udid, device }) {
+	const claim = claimParkedOperation(platform, udid);
+	if (!claim) return null;
+	try {
+		return withConfigLock$1(() => {
+			const cfg = ensureConfig();
+			const records = readParked(platform, { config: cfg });
+			const taken = records.find((r) => r.udid === udid);
+			if (!taken || isLegacyDeletionClaim(taken.deletionClaim)) return null;
+			if (deviceSlotPlatforms(cfg.projects[projectPath], slot)?.[platform]) return null;
+			writeParked(cfg, platform, records.filter((r) => r.udid !== udid));
+			const project = cfg.projects[projectPath];
+			if (!project) throw new Error(`Project not registered: ${projectPath}`);
+			assignSlotDevice(project, platform, device, slot);
+			saveConfig(cfg);
+			const adopted = { ...taken };
+			delete adopted.deletionClaim;
+			return adopted;
+		});
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
+	}
+}
+function claimParkedOperation(platform, udid) {
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: join$1(getConfigDir(), "pool-locks", platform, `${encodeURIComponent(udid.toLowerCase())}.lock`),
+		mode: "exclusive",
+		label: `parked ${platform} device ${udid}`
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	return attempt.acquired ?? null;
+}
+function removeParkedAfter(platform, udid, beforeRemove) {
+	const claim = claimParkedOperation(platform, udid);
+	if (!claim) return null;
+	try {
+		const claimed = withConfigLock$1(() => {
+			const cfg = loadConfig$1();
+			if (!cfg) return null;
+			const records = readParked(platform, { config: cfg });
+			const current = records.find((candidate) => candidate.udid === udid);
+			if (!current) return null;
+			if (isLegacyDeletionClaim(current.deletionClaim)) throw new Error(`Parked ${platform} device ${udid} has a legacy deletionClaim in ${getConfigPath$1()}. Its PID does not establish whether the original operation finished. Keep the device and pool record; after verifying that neither the old Stim process nor its native child is using it, remove only that record's deletionClaim field and retry.`);
+			const record = { ...current };
+			delete record.deletionClaim;
+			const marked = {
+				...record,
+				deletionClaim: {
+					kind: "ownership-claim",
+					claimId: claim.claimId
+				}
+			};
+			writeParked(cfg, platform, records.map((candidate) => candidate.udid === udid ? marked : candidate));
+			saveConfig(cfg);
+			return {
+				record,
+				marked
+			};
+		});
+		if (!claimed) return null;
+		let completed = false;
+		let removed = null;
 		try {
-			renameSync(tmp, file);
-		} catch (error) {
-			rmSync(tmp, { force: true });
-			throw error;
+			(0, ownership_claim_exports.markClaimChildPending)(claim);
+			try {
+				beforeRemove(claimed.record);
+			} finally {
+				(0, ownership_claim_exports.clearClaimChild)(claim);
+			}
+			completed = true;
+		} finally {
+			withConfigLock$1(() => {
+				const cfg = loadConfig$1();
+				if (!cfg) return;
+				const records = readParked(platform, { config: cfg });
+				const current = records.find((candidate) => candidate.udid === udid);
+				if (!isDeepStrictEqual(current, claimed.marked)) return;
+				writeParked(cfg, platform, completed ? records.filter((candidate) => candidate.udid !== udid) : records.map((candidate) => candidate.udid === udid ? claimed.record : candidate));
+				saveConfig(cfg);
+				if (completed) removed = claimed.record;
+			});
 		}
-	}, { ensureParent: () => mkdirSync(dir, { recursive: true }) });
-}
-function recordCreatedDevice(platform, id) {
-	update(platform, (entries) => entries.size !== entries.add(id).size);
+		return removed;
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
+	}
 }
-function forgetCreatedDevice(platform, id) {
-	update(platform, (entries) => entries.delete(id));
+function dropParked(platform, udid) {
+	return removeParkedAfter(platform, udid, () => {}) !== null;
 }
 //#endregion
 //#region src/devices/device-ownership.ts
-const OWNED_SIM_NAME = /^stim-[A-Za-z0-9._-]+ \(.* \d+(?:\.\d+)*\)(?: [A-Za-z0-9-]+)?$/;
-const OWNED_AVD_NAME = /^stim-[A-Za-z0-9._-]+$/;
-const GIB = 1024 ** 3;
-function isOwnedSimName(name) {
-	return OWNED_SIM_NAME.test(name);
-}
-function isOwnedAvdName(name) {
-	return OWNED_AVD_NAME.test(name);
-}
-function avdConfigWrittenByStim(configIni) {
-	for (const line of String(configIni ?? "").split(/\r?\n/)) {
-		const match = /^disk\.dataPartition\.size=(\d+)$/.exec(line.trim());
-		if (match) return Number(match[1]) > 0 && Number(match[1]) % GIB === 0;
+function recordedAsOwned(platform, id) {
+	const config = loadConfig();
+	if (!config) return false;
+	if (platform === "ios" ? readParked("ios", { config }).some((sim) => sim.udid === id) : readParked("android", { config }).some((avd) => avd.name === id)) return true;
+	for (const project of Object.values(config.projects ?? {})) {
+		let slots;
+		try {
+			slots = projectDeviceSlots(project);
+		} catch {
+			continue;
+		}
+		for (const { platforms } of slots) {
+			const record = platforms[platform];
+			if (record?.owned && (platform === "ios" ? record.deviceUdid : record.avdName) === id) return true;
+		}
 	}
 	return false;
 }
-function isStimOwnedSim(sim, created = readCreatedDevices$1()) {
-	const name = sim.name ?? "";
-	return name.startsWith("stim-") && (created.ios.has(sim.udid) || isOwnedSimName(name));
+function isStimOwnedDevice(platform, id) {
+	return readCreatedDevices$1()[platform].has(id) || recordedAsOwned(platform, id);
+}
+function isStimOwnedSim(sim) {
+	return (sim.name ?? "").startsWith("stim-") && isStimOwnedDevice("ios", sim.udid);
 }
-function isStimOwnedAvd(name, readConfig, created = readCreatedDevices$1()) {
-	return isOwnedAvdName(name) && (created.android.has(name) || avdConfigWrittenByStim(readConfig()));
+function isStimOwnedAvd(name) {
+	return name.startsWith("stim-") && isStimOwnedDevice("android", name);
 }
 //#endregion
 //#region src/devices/android.ts
@@ -92,10 +260,10 @@ const ANDROID_ABIS = /* @__PURE__ */ new Set([
 	"x86_64"
 ]);
 const DEFAULT_AVD_DEVICE_PROFILE = String(settingDefinition("android.deviceProfile")?.default);
-function androidHome() {
-	const configured = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+function androidHome(env = process.env) {
+	const configured = env.ANDROID_HOME || env.ANDROID_SDK_ROOT;
 	if (configured) return configured;
-	if (process.platform === "win32") return join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Android", "Sdk");
+	if (process.platform === "win32") return join(env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Android", "Sdk");
 	return join(homedir(), "Library", "Android", "sdk");
 }
 const SDK_TOOL_LOCATIONS = {
@@ -106,19 +274,26 @@ const SDK_TOOL_LOCATIONS = {
 		"latest",
 		"bin",
 		"avdmanager"
+	],
+	sdkmanager: [
+		"cmdline-tools",
+		"latest",
+		"bin",
+		"sdkmanager"
 	]
 };
 const WINDOWS_SDK_TOOL_EXTENSIONS = {
 	emulator: ".exe",
 	adb: ".exe",
-	avdmanager: ".bat"
+	avdmanager: ".bat",
+	sdkmanager: ".bat"
 };
 function androidToolPath(tool, platform = process.platform) {
 	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(androidHome(), ...location.slice(0, -1), name);
-	return existsSync$1(abs) ? abs : bare;
+	return existsSync(abs) ? abs : bare;
 }
 const WINDOWS_BUILD_TOOL_EXTENSIONS = { apksigner: ".bat" };
 function androidBuildToolName(tool, platform = process.platform) {
@@ -140,7 +315,7 @@ function buildToolsMajor(version) {
 	const major = Number(String(version ?? "").split(/[.-]/)[0]);
 	return Number.isFinite(major) ? major : 0;
 }
-function findBuildTool(tools, { home = androidHome(), readDir = readdirSync$1, exists = existsSync$1, platform = process.platform } = {}) {
+function findBuildTool(tools, { home = androidHome(), readDir = readdirSync, exists = existsSync, platform = process.platform } = {}) {
 	const root = join(home, "build-tools");
 	let versions = [];
 	try {
@@ -168,15 +343,23 @@ function androidTool(tool) {
 	const resolved = androidToolPath(tool);
 	return resolved === tool ? tool : `"${resolved}"`;
 }
-function listInstalledSystemImages() {
+function listInstalledSystemImages(onUnreadable) {
 	const root = join(androidHome(), "system-images");
 	const images = [];
-	if (!existsSync$1(root)) return images;
-	for (const apiDir of safeList(root)) {
+	const list = (dir) => {
+		try {
+			return readdirSync(dir);
+		} catch (error) {
+			const code = error.code;
+			if (code !== "ENOENT" && code !== "ENOTDIR") onUnreadable?.(error);
+			return [];
+		}
+	};
+	for (const apiDir of list(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({
+		for (const tag of list(apiPath)) for (const arch of list(join(apiPath, tag))) images.push({
 			api: Number(m[1]),
 			tag,
 			arch,
@@ -185,13 +368,6 @@ function listInstalledSystemImages() {
 	}
 	return images;
 }
-function safeList(dir) {
-	try {
-		return readdirSync$1(dir);
-	} catch {
-		return [];
-	}
-}
 function pageSizeRank(image) {
 	return /(^|_)ps16k$/.test(String(image?.tag || "")) ? 1 : 0;
 }
@@ -211,7 +387,7 @@ function profileNeedsFoldFeature(profile) {
 }
 function systemImageSupportsFold(pkg, home = androidHome()) {
 	try {
-		const ini = readFileSync$1(join(home, ...pkg.split(";"), "advancedFeatures.ini"), "utf8");
+		const ini = readFileSync(join(home, ...pkg.split(";"), "advancedFeatures.ini"), "utf8");
 		return /^\s*SupportPixelFold\s*=\s*on\s*$/im.test(ini);
 	} catch {
 		return false;
@@ -283,7 +459,7 @@ function avdIniValue(configIni, key) {
 	}
 	return null;
 }
-function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync$1(path, "utf8") } = {}) {
+function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8") } = {}) {
 	const directory = avdDirectory(avdName);
 	if (!directory) return null;
 	try {
@@ -310,24 +486,18 @@ function sanitizeAvdLabel(label) {
 function avdConfigIni(avdName, directory = ownedAvdDirectory(avdName)) {
 	if (!directory) return null;
 	try {
-		return readFileSync$1(join(directory, "config.ini"), "utf8");
+		return readFileSync(join(directory, "config.ini"), "utf8");
 	} catch {
 		return null;
 	}
 }
-function registeredOrOrphanedAvdDirectory(avdName) {
-	return ownedAvdDirectory(avdName) ?? listOrphanedAvdDirectories(avdName)[0]?.directory ?? null;
-}
-function isStimOwnedAvdName(avdName, directory) {
-	return isStimOwnedAvd(avdName, () => avdConfigIni(avdName, directory === void 0 ? registeredOrOrphanedAvdDirectory(avdName) : directory));
-}
 function ownedAvdName(label) {
 	const clean = sanitizeAvdLabel(label);
 	return `stim-${clean.startsWith("stim-") ? clean.slice(5) : clean}`;
 }
 const AVDMANAGER_DELETE_TIMEOUT_MS = 12e4;
 function deleteAvd(avdName) {
-	if (!isStimOwnedAvdName(avdName)) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD; Stim has no record of creating it.`);
+	if (!isStimOwnedAvd(avdName)) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD; Stim has no record of creating it.`);
 	getExecutor().run(`${androidTool("avdmanager")} delete avd -n "${avdName}"`, {
 		timeoutMs: AVDMANAGER_DELETE_TIMEOUT_MS,
 		killSignal: "SIGKILL"
@@ -548,28 +718,45 @@ function avdStorageRoots() {
 }
 function avdPathExists(path) {
 	try {
-		lstatSync$1(path);
+		lstatSync(path);
 		return true;
 	} catch (error) {
 		if (error.code === "ENOENT") return false;
 		throw error;
 	}
 }
+/**
+* True only when the AVD home the emulator uses first exists and no AVD root holds a registration or data
+* directory for `avdName`. A missing first root may be an unmounted volume, so it proves nothing; an
+* unreadable path throws.
+*/
+function avdNameAbsent(avdName, roots = avdStorageRoots()) {
+	if (!roots[0] || !isDirectoryPath(roots[0])) return false;
+	return roots.every((root) => !avdPathExists(join(root, `${avdName}.ini`)) && !avdPathExists(join(root, `${avdName}.avd`)));
+}
+function isDirectoryPath(path) {
+	try {
+		return statSync(path).isDirectory();
+	} 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$1(root),
-		names: readdirSync$1(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$1(path, "utf8");
+		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$1(target));
+			registered.add(realpathSync(target));
 		} catch (error) {
 			const code = error.code;
 			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
@@ -584,8 +771,8 @@ function listOrphanedAvdDirectories(avdName) {
 			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$1(directory);
-			if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync$1(directory) !== directory) throw new Error(`Cannot verify AVD data at ${directory}; it was kept.`);
+			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,
@@ -596,7 +783,7 @@ function listOrphanedAvdDirectories(avdName) {
 	}
 	return orphaned;
 }
-function ownedAvdDirectory(avdName, { env = process.env, home = homedir(), readFile = (path) => readFileSync$1(path, "utf8"), realpath = realpathSync$1, isDirectory = (path) => statSync$1(path).isDirectory() } = {}) {
+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,
@@ -630,7 +817,7 @@ const AVD_USER_DATA = [
 	"snapshots"
 ];
 function wipeAvdUserData(directory) {
-	for (const name of AVD_USER_DATA) rmSync$1(join(directory, name), {
+	for (const name of AVD_USER_DATA) rmSync(join(directory, name), {
 		recursive: true,
 		force: true
 	});
@@ -656,10 +843,10 @@ function withAvdConfigOverrides(contents, overrides) {
 	return updated.join(newline) + (trailingNewline ? newline : "");
 }
 let avdConfigWriteSequence = 0;
-function configureNewOwnedAvd(avdName, { dataPartitionSizeGb, avdConfig = {} }, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync$1(path, "utf8"), writeFile = (path, contents) => writeFileSync$1(path, contents, {
+function configureNewOwnedAvd(avdName, { dataPartitionSizeGb, avdConfig = {} }, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8"), writeFile = (path, contents) => writeFileSync(path, contents, {
 	encoding: "utf8",
 	flag: "wx"
-}), rename = renameSync$1, remove = (path) => rmSync$1(path, { force: true }) } = {}) {
+}), 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}.`);
@@ -699,7 +886,7 @@ function avdPoolConfiguration(dataPartitionSizeGb, avdConfig, deviceProfile = DE
 function ownedAvdMatchesConfiguration(avdName, configuration) {
 	const directory = ownedAvdDirectory(avdName);
 	if (!directory) return false;
-	const contents = readFileSync$1(join(directory, "config.ini"), "utf8");
+	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]}`));
 }
@@ -782,7 +969,7 @@ const CRASH_REPORT_MODE_EMULATOR_VERSION = 37;
 function emulatorCrashDatabases(env = process.env) {
 	const root = join(env.TMP || env.TEMP || tmpdir(), "AndroidEmulator");
 	try {
-		return readdirSync$1(root).filter((name) => /^emu-crash-.*\.db$/.test(name)).map((name) => join(root, name));
+		return readdirSync(root).filter((name) => /^emu-crash-.*\.db$/.test(name)).map((name) => join(root, name));
 	} catch {
 		return [];
 	}
@@ -796,7 +983,7 @@ function emulatorCrashDatabases(env = process.env) {
 * removed instead, which has the same effect unless a crash handler is still writing into it.
 * https://github.com/appandflow/stim/issues/918
 */
-function suppressEmulatorCrashConsent({ platform = process.platform, version = emulatorMajorVersion, databases = emulatorCrashDatabases, remove = (path) => rmSync$1(path, {
+function suppressEmulatorCrashConsent({ platform = process.platform, version = emulatorMajorVersion, databases = emulatorCrashDatabases, remove = (path) => rmSync(path, {
 	recursive: true,
 	force: true
 }) } = {}) {
@@ -834,8 +1021,8 @@ function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process
 function emulatorStdio(logFile) {
 	if (!logFile) return "ignore";
 	try {
-		mkdirSync$1(dirname(logFile), { recursive: true });
-		const fd = openSync$1(logFile, "w");
+		mkdirSync(dirname(logFile), { recursive: true });
+		const fd = openSync(logFile, "w");
 		return [
 			"ignore",
 			fd,
@@ -940,7 +1127,7 @@ function avdProcessLockPaths(avdDirectory, platform) {
 }
 function readAvdProcessId(path) {
 	try {
-		const pid = Number(readFileSync$1(path, "utf8").split("\0")[0]);
+		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) {
@@ -964,9 +1151,37 @@ function resolveAvdProcess(avdName, { platform = process.platform, resolveDirect
 		processId: null
 	};
 }
-function assertOwnedAvdStopped(avdName, { processAlive = pidExists, ...resolveOptions } = {}) {
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseAvdEmulatorProcesses(psOutput, avdName) {
+	const command = new RegExp(`(?:^|/)(?:qemu-system-[^\\s/]+|emulator)(?:\\s.*)?\\s(?:-avd\\s+|@)${escapeRegExp(avdName)}(?:\\s|$)`);
+	const pids = [];
+	for (const line of psOutput.split("\n")) {
+		const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+		if (match && command.test(match[2])) pids.push(Number(match[1]));
+	}
+	return pids;
+}
+function listAvdEmulatorProcesses(avdName, platform) {
+	if (platform === "win32") return [];
+	const out = getExecutor().runFileQuiet("ps", [
+		"-axww",
+		"-o",
+		"pid=,command="
+	], { timeoutMs: 5e3 });
+	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.`);
+	return pids;
+}
+function assertOwnedAvdStopped(avdName, { processAlive = pidExists, listProcesses = listAvdEmulatorProcesses, ...resolveOptions } = {}) {
 	const { processId } = resolveAvdProcess(avdName, resolveOptions);
-	if (processId !== null && processAlive(processId)) throw new Error(`Owned AVD ${avdName} still has a live emulator process (${processId}).`);
+	const live = new Set(scanAvdEmulatorProcesses(avdName, resolveOptions.platform ?? process.platform, listProcesses));
+	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(", ")}).`);
 }
 const CRASH_HANDLER_EXIT_TIMEOUT_MS = 15e3;
 /**
@@ -983,23 +1198,85 @@ function emulatorCrashHandlerPids(qemuPid) {
 	], { timeoutMs: 1e4 });
 	return String(out ?? "").split(/\r?\n/).map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid > 0);
 }
-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$1(path).isDirectory(), crashHandlerPids = emulatorCrashHandlerPids, killCrashHandler = (pid) => signalProcessTree(pid, "SIGKILL", { platform }), now = Date.now, sleep = sleepSync } = {}) {
+const EMULATOR_SIGNAL_GRACE_MS = 5e3;
+/**
+* Shuts down the emulator of an owned AVD and returns only once every emulator process launched for it
+* has exited. `shutdown` asks the emulator to quit through its console; it is null when the emulator is
+* not reachable over adb. Processes still running after it get SIGTERM, and SIGKILL if they outlive their
+* 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 } = {}) {
 	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));
+	const identities = /* @__PURE__ */ new Map();
+	for (const pid of scanAvdEmulatorProcesses(avdName, platform, listProcesses)) {
+		const captured = captureIdentity(pid);
+		identities.set(pid, captured.ok ? {
+			pid,
+			processToken: captured.token
+		} : null);
+	}
+	if (processId === null && identities.size === 0) {
+		if (shutdown) throw new Error(`Could not find the emulator process lock for owned AVD ${avdName}.`);
+		return;
+	}
+	const exited = (pid) => {
+		const record = identities.get(pid);
+		if (!record) return !processAlive(pid);
+		const status = inspectIdentity(record);
+		return status === "gone" || status === "different";
+	};
+	const running = () => {
+		const pids = [...identities.keys()].filter((pid) => !exited(pid));
+		if (processId !== null && !identities.has(processId) && processAlive(processId)) pids.push(processId);
+		return pids;
+	};
+	const waitUntil = (until) => {
+		for (;;) {
+			if (running().length === 0) return true;
+			const remaining = until - now();
+			if (remaining <= 0) return false;
+			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);
+	}
+	for (const name of ["SIGTERM", "SIGKILL"]) {
+		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 {}
+		const graceMs = name === "SIGTERM" && !shutdown ? timeoutMs : signalGraceMs;
+		if (waitUntil(now() + graceMs)) break;
+	}
+	const left = new Set(running());
+	for (const pid of scanAvdEmulatorProcesses(avdName, platform, listProcesses)) {
+		const record = identities.get(pid);
+		if (record === void 0 || (record === null ? processAlive(pid) : inspectIdentity(record) !== "gone")) left.add(pid);
+	}
+	if (left.size) {
+		const scanned = platform !== "win32";
+		const unverified = [...left].filter((pid) => {
+			const record = identities.get(pid);
+			return scanned && (record === null || record !== void 0 && inspectIdentity(record) === "different");
+		});
+		const unlisted = [...left].filter((pid) => scanned && pid === processId && !identities.has(pid));
+		throw new Error(`Owned AVD ${avdName} did not finish shutting down after ${Math.ceil((now() - started) / 1e3)}s: emulator process ${[...left].join(", ")} is still running` + (unverified.length ? ` (Stim could not verify the identity of ${unverified.join(", ")}, so it sent no signal)` : "") + (unlisted.length ? ` (${unlisted.join(", ")} holds the AVD process lock, but its command line does not name the AVD, so Stim sent no signal)` : "") + ".");
 	}
-	if (platform === "win32") {
+	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);
@@ -1046,12 +1323,14 @@ function ownedAvdSerialResolver({ timeoutMs } = {}) {
 	const adb = once(() => listAdbDevices(remaining()));
 	const names = /* @__PURE__ */ new Map();
 	const avdNameOf = (serial) => {
-		if (!names.has(serial)) names.set(serial, getAvdNameForSerial(serial, remaining()));
-		return names.get(serial);
+		if (names.has(serial)) return names.get(serial);
+		const name = getAvdNameForSerial(serial, remaining());
+		if (name !== null) names.set(serial, name);
+		return name;
 	};
 	return (avdName) => {
 		if (!avds().includes(avdName)) return { missing: true };
-		if (!isStimOwnedAvdName(avdName)) return { notOwned: true };
+		if (!isStimOwnedAvd(avdName)) return { notOwned: true };
 		const devices = adb();
 		const match = [...devices.emulators, ...devices.unhealthy.filter((entry) => entry.kind === "emulator" && entry.consolePort !== void 0)].find((e) => avdNameOf(e.serial) === avdName);
 		if (match) return { serial: match.serial };
@@ -1059,4 +1338,4 @@ function ownedAvdSerialResolver({ timeoutMs } = {}) {
 	};
 }
 //#endregion
-export { forgetCreatedDevice as $, listOrphanedAvdDirectories as A, pickDefaultSystemImage as B, getAvdNameForSerial as C, listAvdDeviceProfiles as D, listAdbDevices as E, ownedAvdMatchesConfiguration as F, resolvePhysicalDevice as G, profileNeedsFoldFeature as H, ownedAvdName as I, systemImageSupportsFold as J, shutdownAndroidEmulator as K, ownedAvdSerialResolver as L, nextConsolePort as M, ownedAvdDeviceProfile as N, listAvds as O, ownedAvdDirectory as P, isStimOwnedSim as Q, ownedAvdSystemImage as R, findBuildTool as S, isStimOwnedAvdName as T, resetAdoptedAvd as U, probeEmulatorSerial as V, resolveOwnedAvdSerial as W, waitForBoot as X, waitForAndroidEmulatorShutdown as Y, wipeAvdUserData as Z, createOwnedAvd as _, androidHome as a, emulatorFailureRemedy as b, androidSystemImageAbi as c, assertOwnedAvdStopped as d, recordCreatedDevice as et, avdPathExists as f, configureNewOwnedAvd as g, bootAndroidEmulator as h, androidDeviceAbi as i, memoizeEmulatorProbe as j, listInstalledSystemImages as k, androidToolCwd as l, avdStorageRoots as m, OWNED_AVD_CONFIG_DEFAULTS as n, androidPoolCandidates as o, avdPoolConfiguration as p, sleepSync as q, androidBuildToolName as r, androidPoolNoCandidatesRefusal as s, DEFAULT_AVD_DEVICE_PROFILE as t, configuredAndroidEmulatorApp as tt, androidToolPath as u, deleteAvd as v, hostSystemImageArch as w, extractEmulatorFailure as x, emulatorDiskSpaceRemedy as y, physicalDeviceModel as z };
+export { waitForBoot as $, listInstalledSystemImages as A, parseAvdDeviceProfile as B, extractEmulatorFailure as C, listAdbDevices as D, hostSystemImageArch as E, ownedAvdDirectory as F, profileNeedsFoldFeature as G, physicalDeviceModel as H, ownedAvdMatchesConfiguration as I, resolvePhysicalDevice as J, resetAdoptedAvd as K, ownedAvdName as L, memoizeEmulatorProbe as M, nextConsolePort as N, listAvdDeviceProfiles as O, ownedAvdDeviceProfile as P, waitForAndroidEmulatorShutdown as Q, ownedAvdSerialResolver as R, emulatorFailureRemedy as S, getAvdNameForSerial as T, pickDefaultSystemImage as U, parseAvdSystemImage as V, probeEmulatorSerial as W, sleepSync as X, shutdownAndroidEmulator as Y, systemImageSupportsFold as Z, bootAndroidEmulator as _, androidHome as a, dropParked as at, deleteAvd as b, androidSystemImageAbi as c, parkedMaxSetting as ct, assertOwnedAvdStopped as d, selectParked as dt, wipeAvdUserData as et, avdIniPaths as f, configuredAndroidEmulatorApp as ft, avdStorageRoots as g, avdPoolConfiguration as h, androidDeviceAbi as i, adoptParked as it, listOrphanedAvdDirectories as j, listAvds as k, androidToolCwd as l, readParked as lt, avdPathExists as m, OWNED_AVD_CONFIG_DEFAULTS as n, isStimOwnedSim as nt, androidPoolCandidates as o, isLegacyDeletionClaim as ot, avdNameAbsent as p, resolveOwnedAvdSerial as q, androidBuildToolName as r, POOL_SETTING_REMEDY as rt, androidPoolNoCandidatesRefusal as s, parkSim as st, DEFAULT_AVD_DEVICE_PROFILE as t, isStimOwnedAvd as tt, androidToolPath as u, removeParkedAfter as ut, configureNewOwnedAvd as v, findBuildTool as w, emulatorDiskSpaceRemedy as x, createOwnedAvd as y, ownedAvdSystemImage as z };