stim 1.1.0 → 1.3.0

package/dist/android-BqVIJoG7.mjs

@@ -0,0 +1,1368 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { u as getConfigDir } from "./config-CcefMY2Q.mjs";
+import { r as register } from "./cache-manifest-CXR-Y8pH.mjs";
+import { b as sharedBuildCache } from "./state-B3XA2wp2.mjs";
+import { r as pidExists } from "./metro-CORqXyTL.mjs";
+import { a as formatElapsed } from "./command-output-8wHMEde0.mjs";
+import { d as readClaimSet, f as releaseClaim, h as tryAcquireClaim, i as claimRemoveCommand, n as ClaimRefusedError } from "./ownership-claim-Bf2CAfw3.mjs";
+import { c as androidDataPartitionSizeBytes } from "./settings-DEJf6_kJ.mjs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+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, utimesSync, writeFileSync as writeFileSync$1 } from "fs";
+import { homedir } from "os";
+import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$1 } from "path";
+import { buildCacheKey } from "@stim-cli/core";
+import * as expoFingerprint from "@expo/fingerprint";
+import { buildUploadTimeoutMs } from "@stim-cli/cache";
+const ASSET_MANIFEST_FILE = "assets-manifest.json";
+const MAX_DEPTH = 4;
+function hashFile(file) {
+	try {
+		return createHash("sha256").update(readFileSync(file)).digest("hex");
+	} catch {
+		return null;
+	}
+}
+function readAssetManifest(root) {
+	if (!existsSync(root)) return null;
+	const assets = [];
+	let broken = false;
+	const walk = (abs, rel, depth) => {
+		if (depth > MAX_DEPTH || broken) return;
+		let names;
+		try {
+			names = readdirSync(abs);
+		} catch {
+			broken = true;
+			return;
+		}
+		for (const name of names) {
+			const child = join(abs, name);
+			let stat;
+			try {
+				stat = statSync(child);
+			} catch {
+				broken = true;
+				return;
+			}
+			const path = rel === "" ? name : `${rel}/${name}`;
+			if (stat.isDirectory()) {
+				walk(child, path, depth + 1);
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			const sha256 = hashFile(child);
+			if (sha256 === null) {
+				broken = true;
+				return;
+			}
+			assets.push({
+				path,
+				sha256
+			});
+		}
+	};
+	walk(root, "", 0);
+	if (broken) return null;
+	assets.sort((a, b) => a.path.localeCompare(b.path));
+	return {
+		version: 1,
+		assets
+	};
+}
+function parseAssetManifest(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(String(text));
+	} catch {
+		return null;
+	}
+	const obj = parsed;
+	if (!obj || obj.version !== 1 || !Array.isArray(obj.assets)) return null;
+	const assets = [];
+	for (const raw of obj.assets) {
+		const entry = raw;
+		if (typeof entry?.path !== "string" || typeof entry?.sha256 !== "string") return null;
+		assets.push({
+			path: entry.path,
+			sha256: entry.sha256
+		});
+	}
+	return {
+		version: 1,
+		assets
+	};
+}
+function pickGeneratedResDir(names, variant, reactChildren = []) {
+	const wanted = (variant ?? "").trim().toLowerCase();
+	const modern = names.filter((n) => /^createBundle.+JsAndAssets$/.test(n)).toSorted();
+	if (wanted) {
+		const match = modern.find((n) => n.toLowerCase() === `createbundle${wanted}jsandassets`);
+		if (match) return match;
+	} else if (modern.length === 1) return modern[0];
+	if (!names.includes("react")) return null;
+	const children = reactChildren.toSorted();
+	if (wanted) {
+		const match = children.find((n) => n.toLowerCase() === wanted);
+		if (match) return `react/${match}`;
+	} else if (children.length === 1) return `react/${children[0]}`;
+	return null;
+}
+function androidModuleDirs(root, { list = safeList$1 } = {}) {
+	const android = join(root, "android");
+	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join(android, name, "build", "generated", "res"))).toSorted()];
+}
+function findGeneratedResDir(root, variant, { list = safeList$1 } = {}) {
+	for (const module of androidModuleDirs(root, { list })) {
+		const base = join(root, "android", module, "build", "generated", "res");
+		const names = list(base);
+		if (names.length === 0) continue;
+		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join(base, "react")) : []);
+		if (picked) return join(base, ...picked.split("/"));
+	}
+	return null;
+}
+function captureAssetManifest(root, { variant = null, findDir = findGeneratedResDir, read = readAssetManifest } = {}) {
+	const dir = findDir(root, variant);
+	return dir ? read(dir) : null;
+}
+function compareAssetManifests(fresh, stored) {
+	const left = new Map(fresh.assets.map((a) => [a.path, a.sha256]));
+	const right = new Map(stored.assets.map((a) => [a.path, a.sha256]));
+	const added = [];
+	const changed = [];
+	const removed = [];
+	for (const [path, sha256] of left) if (!right.has(path)) added.push(path);
+	else if (right.get(path) !== sha256) changed.push(path);
+	for (const path of right.keys()) if (!left.has(path)) removed.push(path);
+	added.sort();
+	changed.sort();
+	removed.sort();
+	return {
+		same: added.length === 0 && changed.length === 0 && removed.length === 0,
+		added,
+		removed,
+		changed,
+		example: added[0] ?? changed[0] ?? removed[0] ?? null
+	};
+}
+function assetDiffReason(diff) {
+	const which = diff.added.length ? "added" : diff.changed.length ? "changed" : "removed";
+	return `this workspace emits a different asset set than the cached build did (${diff.added.length} added, ${diff.changed.length} changed, ${diff.removed.length} removed; e.g. ${which} ${diff.example})`;
+}
+function safeList$1(dir) {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/build-cache.ts
+function entryDir(platform, key, root = sharedBuildCache()) {
+	return join$1(root, platform, key);
+}
+function artifactIn(dir) {
+	if (!existsSync$1(dir)) return null;
+	let found;
+	try {
+		found = readdirSync$1(dir).find((f) => f.endsWith(".app") || f.endsWith(".apk"));
+	} catch {
+		return null;
+	}
+	return found ? join$1(dir, found) : null;
+}
+const FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
+/**
+* Paths that exist in a working checkout and not in a fresh one, which
+* @expo/fingerprint does not ignore on its own. A fingerprint that counts them
+* cannot match across checkouts, which is the parity failure `doctor` reports.
+*
+* The list stays narrow on purpose: a path belongs here only when no native
+* build on any project can read it. Anything a single project can judge --
+* a lockfile with machine paths, a generated report -- belongs in that
+* project's `.fingerprintignore`, which still applies on top of this.
+*/
+const DEFAULT_FINGERPRINT_IGNORES = ["**/android/local.properties", "**/android/.idea/**"];
+async function fingerprintProject(projectRoot, { platform, createFingerprint = expoFingerprint.createFingerprintAsync, debug = false } = {}) {
+	const result = await createFingerprint(projectRoot, {
+		...platform && FINGERPRINT_PLATFORMS.has(platform) ? { platforms: [platform] } : void 0,
+		...debug ? { debug } : {},
+		ignorePaths: DEFAULT_FINGERPRINT_IGNORES,
+		silent: true
+	});
+	const hash = result?.hash ?? null;
+	if (!hash) return null;
+	return {
+		hash,
+		sources: Array.isArray(result?.sources) ? result.sources : []
+	};
+}
+function registerOnce(root) {
+	try {
+		register({
+			dir: root,
+			name: "Build cache",
+			prune: "entries",
+			entriesDepth: 2,
+			note: "built .app/.apk keyed on the native fingerprint"
+		});
+	} catch {}
+}
+function resolveBuild(platform, key, root = sharedBuildCache()) {
+	const hit = artifactIn(entryDir(platform, key, root));
+	if (!hit) return null;
+	try {
+		utimesSync(dirname$1(hit), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+	} catch {}
+	return hit;
+}
+function storeBuild(platform, key, buildPath, rootOrOptions = {}) {
+	const options = typeof rootOrOptions === "string" ? { root: rootOrOptions } : rootOrOptions || {};
+	const root = options.root || sharedBuildCache();
+	const overwrite = Boolean(options.overwrite);
+	if (!buildPath || !existsSync$1(buildPath)) throw new Error(`No build to store at ${buildPath}`);
+	registerOnce(root);
+	const dest = entryDir(platform, key, root);
+	const existing = artifactIn(dest);
+	if (existing && !overwrite) return existing;
+	const staging = `${dest}.staging-${process.pid}`;
+	rmSync$1(staging, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync$1(staging, { recursive: true });
+	try {
+		getExecutor().runFile("cp", [
+			"-c",
+			"-R",
+			buildPath,
+			join$1(staging, basename$1(buildPath))
+		]);
+	} catch {
+		getExecutor().runFile("cp", [
+			"-R",
+			buildPath,
+			join$1(staging, basename$1(buildPath))
+		]);
+	}
+	if (Array.isArray(options.sources)) try {
+		writeFileSync$1(join$1(staging, SOURCES_FILE), JSON.stringify(options.sources));
+	} catch {}
+	if (options.assetManifest) try {
+		writeFileSync$1(join$1(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
+	} catch {}
+	mkdirSync$1(dirname$1(dest), { recursive: true });
+	rmSync$1(dest, {
+		recursive: true,
+		force: true
+	});
+	renameSync$1(staging, dest);
+	return artifactIn(dest);
+}
+const PROVIDER_DOWNLOAD_DIR = "cache-provider";
+function providerDownloadPath(workspacePath) {
+	return join$1(workspacePath, PROVIDER_DOWNLOAD_DIR);
+}
+/**
+* Empties and registers the scratch directory a provider downloads into. It is
+* created only when a provider is about to be asked, and registered so `gc`
+* reports what an interrupted run left behind.
+*/
+function prepareProviderDownloadDir(dir) {
+	rmSync$1(dir, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync$1(dir, { recursive: true });
+	try {
+		register({
+			dir,
+			name: "Cache provider downloads",
+			prune: "entries",
+			entriesDepth: 1,
+			note: "artifacts fetched from the project cache provider; anything left here is from an interrupted run"
+		});
+	} catch {}
+}
+function filesystemBuildCapability({ root, sources, assetManifest, resolve = resolveBuild, store = storeBuild } = {}) {
+	const stored = {
+		...root === void 0 ? {} : { root },
+		...sources === void 0 ? {} : { sources },
+		...assetManifest === void 0 ? {} : { assetManifest }
+	};
+	return {
+		resolve: ({ platform, key }) => root === void 0 ? resolve(platform, key) : resolve(platform, key, root),
+		store: ({ platform, key, sourcePath, overwrite }) => store(platform, key, sourcePath, {
+			...stored,
+			overwrite
+		})
+	};
+}
+function providerUploadOutcome(result, name) {
+	if (!result) return null;
+	const label = name || "the cache provider";
+	if (result.timedOut) return {
+		line: `${label} upload was cancelled after ${buildUploadTimeoutMs()}ms`,
+		warn: true
+	};
+	if (result.failed) return {
+		line: `${label} upload failed: ${result.failed}`,
+		warn: true
+	};
+	return {
+		line: `uploaded (${label})`,
+		warn: false
+	};
+}
+const SOURCES_FILE = "fingerprint-sources.json";
+function storedSources(platform, key, root = sharedBuildCache()) {
+	try {
+		const parsed = JSON.parse(readFileSync$1(join$1(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
+		return Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function storedAssetManifest(platform, key, root = sharedBuildCache()) {
+	try {
+		return parseAssetManifest(readFileSync$1(join$1(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function sourceName(source) {
+	const s = source;
+	if (typeof s?.filePath === "string" && s.filePath !== "") return s.filePath;
+	if (typeof s?.id === "string" && s.id !== "") return s.id;
+	return null;
+}
+function diffItemName(item) {
+	const o = item;
+	for (const candidate of [
+		o,
+		o?.addedSource,
+		o?.removedSource,
+		o?.afterSource,
+		o?.beforeSource
+	]) {
+		const name = sourceName(candidate);
+		if (name) return name;
+	}
+	return null;
+}
+function compareSourceLists(previous, current) {
+	const previousByName = /* @__PURE__ */ new Map();
+	for (const source of previous) {
+		const name = sourceName(source);
+		if (name !== null) previousByName.set(name, source.hash ?? null);
+	}
+	const changed = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of current) {
+		const name = sourceName(source);
+		if (name === null || seen.has(name)) continue;
+		seen.add(name);
+		const hash = source.hash;
+		if (!previousByName.has(name) || previousByName.get(name) !== (hash ?? null)) changed.push(name);
+	}
+	for (const [name] of previousByName) if (!seen.has(name)) changed.push(name);
+	return changed;
+}
+function diffFingerprintSources({ previous, previousHash = null, current, differ = null }) {
+	if (typeof differ === "function") try {
+		const items = differ({
+			sources: previous,
+			hash: previousHash ?? ""
+		}, {
+			sources: current.sources,
+			hash: current.hash
+		});
+		if (Array.isArray(items)) {
+			const names = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const item of items) {
+				const name = diffItemName(item);
+				if (name !== null && !seen.has(name)) {
+					seen.add(name);
+					names.push(name);
+				}
+			}
+			return names;
+		}
+	} catch {}
+	return compareSourceLists(previous, current.sources);
+}
+function fingerprintDiffSuffix(changed) {
+	if (!changed.length) return "";
+	const shown = changed.slice(0, 3).join(", ");
+	return ` -- ${changed.length} source${changed.length === 1 ? "" : "s"} changed: ${shown}`;
+}
+function describeFingerprintMiss({ platform, current, lastBuild, root = sharedBuildCache(), differ = expoFingerprint.diffFingerprints }) {
+	if (!lastBuild || lastBuild.platform !== platform) return null;
+	const previousHash = typeof lastBuild.fingerprint === "string" ? lastBuild.fingerprint : null;
+	const previousKey = typeof lastBuild.cacheKey === "string" ? lastBuild.cacheKey : null;
+	if (!previousHash || !previousKey || previousHash === current.hash) return null;
+	const previous = storedSources(platform, previousKey, root);
+	if (!previous) return null;
+	const changed = diffFingerprintSources({
+		previous,
+		previousHash,
+		current,
+		differ
+	});
+	return changed.length ? {
+		changed,
+		previousHash
+	} : null;
+}
+async function refingerprintAfterMutation({ projectRoot, platform, previousHash, fingerprint = fingerprintProject }) {
+	let computed = null;
+	try {
+		computed = await fingerprint(projectRoot, { platform });
+	} catch {
+		return null;
+	}
+	if (!computed?.hash) return null;
+	return {
+		hash: computed.hash,
+		sources: computed.sources,
+		moved: computed.hash !== previousHash
+	};
+}
+function untrackedNativeFiles({ projectRoot, exec = getExecutor() }) {
+	let out;
+	try {
+		out = exec.runFile("git", [
+			"-C",
+			projectRoot,
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"--",
+			"ios",
+			"android"
+		]);
+	} catch {
+		return [];
+	}
+	return String(out || "").split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+function untrackedMissLine(files, cap = 3) {
+	if (!Array.isArray(files) || files.length === 0) return null;
+	const shown = files.slice(0, cap);
+	const more = files.length > shown.length ? `, and ${files.length - shown.length} more` : "";
+	return `no previous entry to diff against; ${files.length} untracked file${files.length === 1 ? "" : "s"} under ios/ or android/ are hashed like any other source: ${shown.join(", ")}${more} -- list the build-irrelevant ones in .fingerprintignore`;
+}
+function fingerprintDiffRecord({ changed, previousHash, hash }) {
+	const shown = changed.slice(0, 20);
+	return {
+		src: "build",
+		level: "info",
+		event: "fingerprint_diff",
+		msg: `fingerprint ${previousHash} -> ${hash}: ${changed.length} source${changed.length === 1 ? "" : "s"} changed: ` + shown.join(", ") + (changed.length > shown.length ? `, and ${changed.length - shown.length} more` : ""),
+		changed: changed.length,
+		sources: shown
+	};
+}
+//#endregion
+//#region src/engine/build-lock.ts
+const LOCK_SUFFIX = ".lock";
+const WAIT_POLL_MS = 1e3;
+const WAIT_PROGRESS_MS = 3e4;
+const WAIT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function segment(value) {
+	return String(value).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "unknown";
+}
+function buildLocksDir() {
+	return join(getConfigDir(), "build-locks");
+}
+function buildLockPath(platform, key) {
+	return join(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX}`);
+}
+function label(platform) {
+	return `${platform} build`;
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function readBuildLock(pathOrSpec) {
+	const path = typeof pathOrSpec === "string" ? pathOrSpec : buildLockPath(pathOrSpec.platform, pathOrSpec.key);
+	const survey = readClaimSet(path);
+	const holder = survey.live[0] ?? survey.dead[0];
+	return holder ? toRecord(holder) : null;
+}
+function acquireBuildLock({ platform, key, root = null, logFile = null }) {
+	const path = buildLockPath(platform, key);
+	const attempt = tryAcquireClaim({
+		root: path,
+		mode: "exclusive",
+		label: label(platform),
+		details: {
+			projectRoot: root,
+			logFile
+		}
+	});
+	const reaped = attempt.reaped[0];
+	if (attempt.acquired) {
+		const handle = {
+			acquired: true,
+			path,
+			lock: {
+				pid: attempt.acquired.owner.pid,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+		return reaped ? {
+			...handle,
+			tookOver: toRecord(reaped)
+		} : handle;
+	}
+	if (attempt.pending) releaseClaim(attempt.pending);
+	const holder = attempt.held ?? attempt.waitingFor?.[0];
+	return holder ? {
+		held: toRecord(holder),
+		path
+	} : { path };
+}
+function releaseBuildLock(handle) {
+	return releaseClaim(handle?.claim);
+}
+function listBuildLocks() {
+	const dir = buildLocksDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const locks = [];
+	for (const name of names) {
+		if (!name.endsWith(LOCK_SUFFIX)) continue;
+		const path = join(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		const survey = readClaimSet(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		locks.push({
+			path,
+			name,
+			platform: cut > 0 ? stem.slice(0, cut) : stem,
+			key: cut > 0 ? stem.slice(cut + 1) : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return locks;
+}
+function waitingLine({ projectRoot, pid, elapsedMs, logFile }) {
+	const where = projectRoot || "another workspace";
+	const tail = logFile ? ` -- tail ${logFile}` : "";
+	return `${"build".padEnd(11)} waiting on ${where} (pid ${pid ?? "?"}, ${formatElapsed(elapsedMs)} elapsed)${tail} -- stim guide lifecycle concurrency`;
+}
+function takeoverLine({ projectRoot, pid, logFile, startedAt = null, now = Date.now }) {
+	const where = projectRoot || "another workspace";
+	const started = startedAt ? Date.parse(startedAt) : NaN;
+	const ago = Number.isFinite(started) ? ` (it started ${formatElapsed(now() - started)} ago)` : "";
+	const tail = logFile ? ` -- read ${logFile} before this one finishes` : "";
+	return `RETRY: ${where}'s build of this fingerprint (pid ${pid ?? "?"}) FAILED without an artifact${ago}, and this run rebuilds the SAME inputs, so expect the same failure unless something changed${tail}`;
+}
+async function waitForBuild({ platform, key, resolve = resolveBuild, intervalMs = WAIT_POLL_MS, progressMs = WAIT_PROGRESS_MS, ceilingMs = WAIT_CEILING_MS, out = () => {}, now = Date.now, sleep = sleepAsync }) {
+	const path = buildLockPath(platform, key);
+	const started = now();
+	let lastProgress = started;
+	let holder = readBuildLock(path);
+	for (;;) {
+		const hit = resolve(platform, key);
+		if (hit) return {
+			hit,
+			waitedMs: now() - started
+		};
+		const survey = readClaimSet(path);
+		const unresolved = survey.unresolved[0];
+		if (unresolved) throw new ClaimRefusedError({
+			claimPath: unresolved.path,
+			root: path,
+			label: label(platform),
+			reason: unresolved.reason
+		});
+		const live = survey.live[0];
+		if (live) holder = toRecord(live);
+		else {
+			const dead = survey.dead[0];
+			if (dead) return {
+				builderFailed: `the builder (pid ${dead.owner.pid}) is gone`,
+				holder: toRecord(dead),
+				waitedMs: now() - started
+			};
+			return {
+				lockReleased: true,
+				holder,
+				waitedMs: now() - started
+			};
+		}
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for ${holder?.projectRoot || "another workspace"}'s ${platform} build of ${key} without an artifact, and pid ${holder?.pid} is still the live holder. The lock is ${path}; remove it if that process is not really building:\n  ${claimRemoveCommand(path)}`);
+			err.code = "STIM_BUILD_WAIT_TIMEOUT";
+			err.lockPath = path;
+			err.holder = holder ?? void 0;
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(waitingLine({
+				projectRoot: holder.projectRoot,
+				pid: holder.pid,
+				elapsedMs: elapsed,
+				logFile: holder.logFile
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+//#endregion
+//#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$1(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$1(androidHome(), ...SDK_TOOL_LOCATIONS[tool]);
+	return existsSync$1(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$1, exists = existsSync$1 } = {}) {
+	const root = join$1(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$1(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$1(androidHome(), "system-images");
+	const images = [];
+	if (!existsSync$1(root)) return images;
+	for (const apiDir of safeList(root)) {
+		const m = apiDir.match(/^android-(\d+)$/);
+		if (!m) continue;
+		const apiPath = join$1(root, apiDir);
+		for (const tag of safeList(apiPath)) for (const arch of safeList(join$1(apiPath, tag))) images.push({
+			api: Number(m[1]),
+			tag,
+			arch,
+			pkg: `system-images;${apiDir};${tag};${arch}`
+		});
+	}
+	return images;
+}
+function safeList(dir) {
+	try {
+		return readdirSync$1(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$1(path, "utf8") } = {}) {
+	const directory = avdDirectory(avdName);
+	if (!directory) return null;
+	try {
+		return parseAvdSystemImage(readFile(join$1(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$1(parsed.relativePath) ? resolve$1(dirname$1(root), parsed.relativePath) : null, parsed.path && isAbsolute$1(parsed.path) ? parsed.path : null].filter((candidate) => candidate !== null);
+}
+function avdStorageRoots() {
+	const env = process.env;
+	return [...new Set([
+		env.ANDROID_AVD_HOME,
+		env.ANDROID_EMULATOR_HOME ? join$1(env.ANDROID_EMULATOR_HOME, "avd") : null,
+		env.ANDROID_USER_HOME ? join$1(env.ANDROID_USER_HOME, "avd") : null,
+		env.ANDROID_SDK_HOME ? join$1(env.ANDROID_SDK_HOME, ".android", "avd") : null,
+		env.ANDROID_SDK_HOME ? join$1(env.ANDROID_SDK_HOME, "avd") : null,
+		join$1(homedir(), ".android", "avd")
+	].filter((value) => Boolean(value)))];
+}
+function avdPathExists(path) {
+	try {
+		lstatSync$1(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$1(root),
+		names: readdirSync$1(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$1(root, name);
+		const ini = readFileSync$1(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));
+		} 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$1(candidate, `${name}.ini`)))) continue;
+			const directory = join$1(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.`);
+			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$1(path, "utf8"), realpath = realpathSync$1, isDirectory = (path) => statSync$1(path).isDirectory() } = {}) {
+	if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return null;
+	const roots = [
+		env.ANDROID_AVD_HOME,
+		env.ANDROID_SDK_HOME ? join$1(env.ANDROID_SDK_HOME, "avd") : null,
+		join$1(home, ".android", "avd")
+	];
+	for (const root of new Set(roots.filter((value) => Boolean(value)))) {
+		let ini;
+		try {
+			ini = readFile(join$1(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$1(path, "utf8"), writeFile = (path, contents) => writeFileSync$1(path, contents, {
+	encoding: "utf8",
+	flag: "wx"
+}), rename = renameSync$1, remove = (path) => rmSync$1(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$1(directory, "config.ini");
+	const original = readFile(configPath);
+	const expected = {
+		...avdConfig,
+		"disk.dataPartition.size": String(sizeBytes)
+	};
+	const updated = withAvdConfigOverrides(original, expected);
+	const tempPath = join$1(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$1(join$1(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$1(dirname$1(logFile), { recursive: true });
+		const fd = openSync$1(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$1(avdDirectory, name, ...platform === "win32" ? ["pid"] : []));
+}
+function readAvdProcessId(path) {
+	try {
+		const pid = Number(readFileSync$1(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$1(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 { providerDownloadPath as $, pickDefaultSystemImage as A, listBuildLocks as B, memoizeEmulatorProbe as C, ownedAvdName as D, ownedAvdMatchesConfiguration as E, shutdownAndroidEmulator as F, buildCacheKey as G, segment as H, waitForAndroidEmulatorShutdown as I, filesystemBuildCapability as J, describeFingerprintMiss as K, waitForBoot as L, resetAdoptedAvd as M, resolveOwnedAvdSerial as N, ownedAvdSystemImage as O, resolvePhysicalDevice as P, prepareProviderDownloadDir as Q, WAIT_CEILING_MS as R, listOrphanedAvdDirectories as S, ownedAvdDirectory as T, takeoverLine as U, releaseBuildLock as V, waitForBuild as W, fingerprintDiffSuffix as X, fingerprintDiffRecord as Y, fingerprintProject as Z, findBuildTool as _, androidSystemImageAbi as a, untrackedMissLine as at, listAvds as b, avdPoolConfiguration as c, captureAssetManifest as ct, configureNewOwnedAvd as d, providerUploadOutcome as et, createOwnedAvd as f, extractEmulatorFailure as g, emulatorFailureRemedy as h, androidPoolNoCandidatesRefusal as i, storedAssetManifest as it, probeEmulatorSerial as j, physicalDeviceModel as k, avdStorageRoots as l, compareAssetManifests as lt, emulatorDiskSpaceRemedy as m, androidHome as n, resolveBuild as nt, assertOwnedAvdStopped as o, untrackedNativeFiles as ot, deleteAvd as p, diffFingerprintSources as q, androidPoolCandidates as r, storeBuild as rt, avdPathExists as s, assetDiffReason as st, androidDeviceAbi as t, refingerprintAfterMutation as tt, bootAndroidEmulator as u, readAssetManifest as ut, getAvdNameForSerial as v, nextConsolePort as w, listInstalledSystemImages as x, listAdbDevices as y, acquireBuildLock as z };