stim 1.19.0 → 1.20.0

package/dist/miss-reason-CjQCOKqq.mjs

@@ -1,1743 +0,0 @@
-import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
-import { D as withConfigLock$1, H as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, b as releaseAndroidConsolePort, i as clearAndroidBootPending, k as acquireAvdClaim, p as getProject, t as allConsolePortsAndSerials, w as setDevice, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
-import { d as sharedBuildCache } from "./workspace-state-CR9X86xJ.mjs";
-import { E as readMetroTunnel, O as readRemoteSession, o as ownedDeviceLabel } from "./project-B5eQ1USs.mjs";
-import { Ct as removeTemporaryEntry, J as planMetroReach, St as makeTemporaryDirectory, a as androidAvdConfigSetting, c as androidDataPartitionSizeGbSetting, q as detectProviders, rt as gitCommonDirOnDisk } from "./settings-CxgngUZk.mjs";
-import { s as pidExists } from "./metro-DI2AjPF_.mjs";
-import { s as peekBudget } from "./budget-Dz-kyXLv.mjs";
-import { A as teardownParkedAvd, D as teardownOwnedAvd } from "./workspaces-Djb2gfi9.mjs";
-import { C as diffFingerprintSources, I as storedSources } from "./device-lease-Cu7PtQpZ.mjs";
-import { A as listAvds, B as ownedAvdSystemImage, E as getAvdNameForSerial, F as ownedAvdDeviceProfile, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, O as listAdbDevices, P as nextConsolePort, R as ownedAvdName, W as pickDefaultSystemImage, b as createOwnedAvd, f as assertOwnedAvdStopped, ft as parkedMaxSetting, g as avdPoolConfiguration, j as listInstalledSystemImages, n as OWNED_AVD_CONFIG_DEFAULTS, pt as readParked, st as adoptParked, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, ut as isLegacyDeletionClaim, v as bootAndroidEmulator, y as configureNewOwnedAvd } from "./android-BdQC6zs1.mjs";
-import { M as readHostMemoryPressure, d as listAllIosSims } from "./ios-BWbHFZVz.mjs";
-import { E as namedBuildMachine, N as hostingMachines, k as resolveBuildMachine } from "./client-CuUo8Nvg.mjs";
-import { t as clearDeviceIdleShutdown } from "./idle-shutdown-DYiMBn34.mjs";
-import { i as countLiveOwnedDevices, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission, s as peekDeviceSlots } from "./device-capacity-BoN1jQkO.mjs";
-import { E as startBuildHeartbeat, O as tailLines, h as HEARTBEAT_INTERVAL_MS } from "./toolchain-C3xSoyUl.mjs";
-import { t as cleanLine } from "./server-expo-n3tUi3Em.mjs";
-import { a as call, o as connectHost } from "./hosted-client-C5G4h_OJ.mjs";
-import { r as readHostedNative, s as writeHostedNative } from "./ios-state-By0XuLTQ.mjs";
-import { n as prepareHostedNative } from "./hosted-native-DbV2aUVw.mjs";
-import { f as resolveEasCliBin, s as isEasAuthFailureText } from "./remote-cache-N3hAEaAL.mjs";
-import { i as ensureOwnedIosDevice, r as ensureIosBooted } from "./device-ios-B2ruohE-.mjs";
-import { _ as MIN_EAS_CLI_SIMULATOR_VERSION, g as MIN_EAS_CLI_DEVICE_VERSION, s as readInstalledEasCliVersion, v as easCliSupport } from "./device-remote-B5GiUifk.mjs";
-import { t as reconcileSimSlim } from "./simslim-D9LkJxIO.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import { LAST_BUILD_KEYS, automaticMachineEnabled, isJsonObject, loadConfig, machineCapacity, parseHostedChoice, parseHostedNativeOffer, readWorkspaceState } from "@stim-cli/core/state";
-import chalk from "chalk";
-import { isDeepStrictEqual } from "node:util";
-import { claimRemoveCommand, clearClaimChild, markClaimChildPending, processGroupAlive, releaseClaim, setClaimChild } from "@stim-cli/core/ownership-claim";
-import { captureProcessIdentity } from "@stim-cli/core/process-identity";
-import { randomUUID } from "node:crypto";
-import * as expoFingerprint from "@expo/fingerprint";
-import { request } from "node:http";
-//#region src/device-host/placement.ts
-function local$1(code, reason, skipped = [], atCapacity = false) {
-	return {
-		kind: "local",
-		code,
-		reason,
-		skipped,
-		...atCapacity ? { atCapacity: true } : {}
-	};
-}
-function decideDevicePlacement(inputs) {
-	if ("sticky" in inputs) {
-		if ("machine" in inputs.sticky) {
-			const reason = `recorded session on ${inputs.sticky.machine}`;
-			return {
-				kind: "host",
-				code: "sticky",
-				reason,
-				machines: [{
-					machine: inputs.sticky.machine,
-					reason
-				}],
-				skipped: []
-			};
-		}
-		return {
-			kind: "local",
-			code: "sticky",
-			reason: "this workspace's device runs here",
-			skipped: []
-		};
-	}
-	const { platform, here, offers, buildMachine, noWait, eas } = inputs;
-	const { count, max, queued } = here.devices;
-	const room = max === 0 || count !== null && count < max;
-	const localEnabled = here.localEnabled !== false;
-	const cannotTake = !localEnabled || !room || queued > 0;
-	const atCapacity = count !== null && (!room || queued > 0);
-	const usage = max > 0 ? `${count} of ${max} devices in use` : `${count} devices in use, no device cap`;
-	const localReason = !localEnabled ? "local is disabled in remote.devicePoolDisabled" : count === null ? "cannot tell how many devices run here; local boot admission decides" : cannotTake ? `${usage}${queued ? `, ${queued} runs queued ahead` : ""}` : here.budgetRefusal ?? (here.memoryPressure !== "normal" ? `host memory pressure ${here.memoryPressure ?? "unknown"} here` : `load ${here.loadPerCore.toFixed(1)}/core here, ${usage}`);
-	const nowhere = (code, reason, skipped = [], waiting = "") => {
-		if (!localEnabled && !atCapacity) return {
-			kind: "refused",
-			code: "pool-unavailable",
-			reason,
-			skipped
-		};
-		if (!cannotTake || count === null) return local$1(code, reason + waiting, skipped);
-		if (eas?.usable) return {
-			kind: "eas",
-			code: "eas-fallback",
-			reason: `${reason}; EAS Simulator (remote.easFallback)`,
-			skipped
-		};
-		const why = eas ? [...skipped, {
-			machine: "eas",
-			code: eas.code,
-			reason: eas.reason
-		}] : skipped;
-		return localEnabled ? local$1(code, reason + waiting, why, true) : {
-			kind: "refused",
-			code: "pool-unavailable",
-			reason,
-			skipped: why,
-			atCapacity: true
-		};
-	};
-	if (!offers.length) return nowhere("no-remote-mac", "no remote Macs configured; " + localReason);
-	if (localEnabled && count === null) return local$1("device-count-unknown", localReason);
-	if (!cannotTake && here.memoryPressure === "normal" && !here.budgetRefusal && here.loadPerCore < here.maxLoadPerCore) return local$1("this-mac-free", localReason);
-	const skipped = [];
-	const admitted = [];
-	offers.forEach((probe, index) => {
-		let reason = null;
-		let code = "unreachable";
-		if ("failure" in probe) reason = probe.failure;
-		else {
-			const { offer } = probe;
-			if (offer.declined !== null) [code, reason] = ["declined", `declined: ${offer.declined}`];
-			else if (offer.platform !== platform || !offer.choice) [code, reason] = ["no-matching-device", `no matching ${platform} device choice`];
-			else if (offer.resources.memoryPressure !== "normal") [code, reason] = ["memory", "host memory pressure unknown or elevated"];
-			else if (offer.capacity.available === 0) [code, reason] = ["no-capacity", "no hosted device capacity available"];
-			else if (!cannotTake && (offer.resources.loadPerCore === null || offer.resources.loadPerCore >= here.loadPerCore)) [code, reason] = ["load", offer.resources.loadPerCore === null ? "host load unknown while this Mac has room" : "host is not less loaded than this Mac"];
-			else admitted.push({
-				machine: probe.machine,
-				offer,
-				index
-			});
-		}
-		if (reason) skipped.push({
-			machine: probe.machine,
-			code,
-			reason
-		});
-	});
-	admitted.sort((a, b) => Number(b.machine === buildMachine) - Number(a.machine === buildMachine) || (a.offer.resources.loadPerCore ?? Infinity) - (b.offer.resources.loadPerCore ?? Infinity) || b.offer.resources.memoryFreeBytes - a.offer.resources.memoryFreeBytes || a.index - b.index);
-	if (!admitted.length) return nowhere("no-host-admits", `${localReason}; no host admits`, skipped, localEnabled && cannotTake && !noWait ? "; waiting locally if needed" : "");
-	const machines = admitted.map(({ machine, offer }) => ({
-		machine,
-		reason: `${localReason}; ${machine}${machine === buildMachine ? " is the explicit remote Mac," : ""} load ${offer.resources.loadPerCore === null ? "unknown" : offer.resources.loadPerCore.toFixed(1) + "/core"}`
-	}));
-	return {
-		kind: "host",
-		code: "placed",
-		machines,
-		reason: machines[0].reason,
-		skipped
-	};
-}
-//#endregion
-//#region src/device-host/auto-placement.ts
-async function probeHost(machine, platform, selectors) {
-	let host;
-	const deadline = Date.now() + 3e3;
-	try {
-		host = await connectHost(machine, 3e3, true);
-		const offer = await call(host, "device-host.offer", {
-			platform,
-			...selectors
-		}, Math.max(1, deadline - Date.now()));
-		const resources = isJsonObject(offer.resources) ? offer.resources : {};
-		const parsed = parseHostedNativeOffer({
-			...offer,
-			resources: {
-				...resources,
-				loadPerCore: resources.loadPerCore ?? 0
-			}
-		});
-		let choice = platform === "ios" ? offer.platform === "ios" ? parseHostedChoice(offer.choice) : null : parsed?.platform === "android" ? parsed.choice : null;
-		if (choice && ("runtime" in choice ? selectors.deviceType && selectors.deviceType !== choice.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== choice.runtime.replace(/^iOS /, "") : selectors.systemImage && selectors.systemImage !== choice.systemImage || selectors.deviceProfile && selectors.deviceProfile !== choice.deviceProfile)) choice = null;
-		if (!isJsonObject(offer.capacity) || offer.declined !== null && typeof offer.declined !== "string") throw new Error("unreadable device offer");
-		return {
-			probe: {
-				machine,
-				offer: {
-					platform,
-					choice,
-					declined: offer.declined,
-					capacity: { available: typeof offer.capacity.available === "number" ? offer.capacity.available : null },
-					resources: {
-						loadPerCore: typeof resources.loadPerCore === "number" && Number.isFinite(resources.loadPerCore) && resources.loadPerCore >= 0 ? resources.loadPerCore : null,
-						memoryFreeBytes: typeof resources.memoryFreeBytes === "number" ? resources.memoryFreeBytes : 0,
-						memoryPressure: typeof resources.memoryPressure === "string" ? resources.memoryPressure : null
-					}
-				}
-			},
-			...choice ? { target: {
-				host,
-				choice,
-				session: null
-			} } : {}
-		};
-	} catch (error) {
-		return { probe: {
-			machine,
-			failure: error instanceof Error ? error.message : String(error)
-		} };
-	} finally {
-		host?.connection.close();
-	}
-}
-function hosted(target, code, reason, skipped = []) {
-	target.selection = {
-		selected: "auto",
-		reason
-	};
-	return {
-		target,
-		placement: {
-			decision: "hosted",
-			machine: target.host.machine,
-			reason
-		},
-		code,
-		skipped
-	};
-}
-function local(code, reason, skipped = []) {
-	return {
-		target: null,
-		placement: {
-			decision: "local",
-			reason
-		},
-		code,
-		skipped
-	};
-}
-function viaEas(code, reason, skipped) {
-	return {
-		target: null,
-		placement: {
-			decision: "eas",
-			machine: "eas",
-			reason
-		},
-		code,
-		skipped
-	};
-}
-async function automaticDevicePlacement({ root, slot, platform, selectors, buildMachine, noWait, eas }, { machines = hostingMachines, read = readHostedNative, write = writeHostedNative, resume = prepareHostedNative, peek = () => peekDeviceSlots({
-	platform,
-	project: getProject(root),
-	slot
-}), capacity = machineCapacity, memory = readHostMemoryPressure, probe = probeHost, budget = peekBudget } = {}) {
-	const recorded = read(root, platform, slot)[slot];
-	if (recorded) {
-		const target = await resume(recorded.machine, selectors, recorded, platform, true);
-		if (target) return {
-			target,
-			placement: {
-				decision: "hosted",
-				machine: recorded.machine,
-				reason: recorded.reason ?? decideDevicePlacement({ sticky: { machine: recorded.machine } }).reason
-			},
-			code: "sticky",
-			skipped: [],
-			sticky: true
-		};
-		write(root, slot, null, platform);
-	}
-	const devices = peek();
-	if (devices.localLive) return {
-		...local("sticky", decideDevicePlacement({ sticky: { local: true } }).reason),
-		sticky: true
-	};
-	const configured = machines();
-	if (configured === null) throw Object.assign(/* @__PURE__ */ new Error("remote.machines is invalid. Run stim guide settings and correct it."), { code: "STIM_HOSTING_REFUSED" });
-	const config = loadConfig$1();
-	const entries = configured.filter((machine) => automaticMachineEnabled("device", machine, config));
-	const preference = resolveBuildMachine(buildMachine, process.env.STIM_REMOTE_BUILD, config?.remote?.build);
-	buildMachine = namedBuildMachine(preference) ? preference : void 0;
-	const load = capacity();
-	const here = {
-		localEnabled: automaticMachineEnabled("device", "local", config),
-		loadPerCore: load.loadPerCore,
-		maxLoadPerCore: load.maxLoadPerCore,
-		memoryPressure: memory(),
-		devices,
-		budgetRefusal: await budget(root)
-	};
-	const inputs = (offers) => ({
-		platform,
-		here,
-		offers,
-		buildMachine,
-		noWait
-	});
-	const notProbed = entries.map((machine) => ({
-		machine,
-		failure: "not probed"
-	}));
-	const early = decideDevicePlacement(inputs(notProbed));
-	const probes = early.kind === "local" && early.skipped.length === 0 ? [] : await Promise.all(entries.map((machine) => probe(machine, platform, selectors)));
-	const offers = probes.length ? probes.map((each) => each.probe) : notProbed;
-	let decision = decideDevicePlacement(inputs(offers));
-	if ((decision.kind === "local" || decision.kind === "refused") && decision.atCapacity && eas) decision = decideDevicePlacement({
-		...inputs(offers),
-		eas: await eas()
-	});
-	if (decision.kind === "refused") throw Object.assign(new Error(devicePlacementLine({
-		decision: "local",
-		reason: decision.reason
-	}, decision.skipped)), {
-		code: "STIM_HOSTING_REFUSED",
-		remedy: "Enable an available member in remote.devicePoolDisabled or select a machine explicitly."
-	});
-	if (decision.kind === "eas") return viaEas(decision.code, decision.reason, decision.skipped);
-	if (decision.kind === "local") return local(decision.code, decision.reason, decision.skipped);
-	const target = probes.find((each) => each.probe.machine === decision.machines[0].machine).target;
-	return hosted(target, decision.code, decision.reason, decision.skipped);
-}
-function devicePlacementLine(placement, skipped) {
-	return `${placement.machine ?? "local"}, ${placement.reason}${placement.decision !== "hosted" && skipped.length ? "; " + skipped.map((each) => `${each.machine}: ${each.reason}`).join("; ") : ""}`;
-}
-//#endregion
-//#region src/engine/eas-fallback.ts
-const AVAILABILITY_TIMEOUT_MS = 3e4;
-function unusable(code, reason) {
-	return {
-		usable: false,
-		code,
-		reason
-	};
-}
-/** Reads `eas simulator:availability --json`: `{"available": true, ...}` on stdout, or a failure on stderr. */
-function parseSimulatorAvailability(outcome) {
-	if ("failure" in outcome) {
-		if (outcome.timedOut) return unusable("eas-unavailable", "eas simulator:availability timed out");
-		const detail = outcome.failure.split("\n").map((line) => line.trim()).find((line) => line && !/is now available\.$|^(To upgrade|npm install|Proceeding with|\(node:|\(Use `node)/.test(line));
-		if (isEasAuthFailureText(outcome.failure)) return unusable("eas-logged-out", "eas-cli is not logged in (run eas login or set EXPO_TOKEN)");
-		return unusable("eas-unavailable", `eas simulator:availability failed${detail ? `: ${detail}` : ""}`);
-	}
-	let data = null;
-	try {
-		data = JSON.parse(outcome.stdout.slice(outcome.stdout.indexOf("{")));
-	} catch {}
-	if (typeof data !== "object" || data === null || typeof data.available !== "boolean") return unusable("eas-unavailable", "eas simulator:availability printed no availability");
-	return data.available ? { usable: true } : unusable("eas-not-enabled", "EAS Simulator is not enabled for this EAS account");
-}
-/**
-* Whether this run could use an EAS Simulator the way `--remote eas` does, without starting a session or a build.
-* Each refusal names what `--remote eas` would refuse later, so automatic placement falls through instead.
-*/
-async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelMode, publicUrl, deviceTypeFlag, localOnlyFlags, env = process.env, resolveBin = resolveEasCliBin, readVersion = readInstalledEasCliVersion, onPath = (bin) => getExecutor().findExecutable(bin) !== null, readTunnel = readMetroTunnel, readSession = readRemoteSession, metroPort = () => getProject(root)?.metroPort ?? null, availability = async (bin) => {
-	try {
-		return { stdout: await getExecutor().runFileAsync(bin, [
-			"simulator:availability",
-			"--json",
-			"--non-interactive"
-		], {
-			cwd: root,
-			timeoutMs: AVAILABILITY_TIMEOUT_MS
-		}) };
-	} catch (error) {
-		const err = error;
-		return {
-			failure: String(err.stderr || err.message || error),
-			timedOut: err.code === "ETIMEDOUT"
-		};
-	}
-} }) {
-	if (slot !== "default") return unusable("eas-named-slot", `an EAS Simulator takes only the default slot, not ${slot}`);
-	if (localOnlyFlags.length) return unusable("eas-local-flags", `${localOnlyFlags.join(" and ")} applies only to a ${platform} device on a Mac`);
-	const session = readSession(root);
-	if (session && session.platform !== platform) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.platform ?? "another platform"}`);
-	if (session && deviceTypeFlag?.trim() && session.deviceType !== deviceTypeFlag.trim()) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.deviceType ?? "the model EAS chose"}, not ${deviceTypeFlag.trim()}`);
-	if (!onPath("agent-device")) return unusable("eas-no-agent-device", "agent-device is not on PATH");
-	const bin = resolveBin(root);
-	if (!bin) return unusable("eas-no-cli", "eas-cli is not installed for this project or on PATH");
-	const versionOutput = readVersion(bin.file, root);
-	const minimum = platform === "ios" && deviceTypeFlag?.trim() ? MIN_EAS_CLI_DEVICE_VERSION : MIN_EAS_CLI_SIMULATOR_VERSION;
-	const { supported, version } = easCliSupport(versionOutput, minimum);
-	if (!supported) return unusable("eas-cli-too-old", `eas-cli ${version ?? "(unknown version)"} is older than ${minimum}`);
-	if (!release) {
-		const mode = tunnelMode ?? "auto";
-		if (mode === "off") return unusable("eas-metro-unreachable", "metro.tunnel is off, so an EAS Simulator cannot reach Metro");
-		const plan = planMetroReach({
-			mode,
-			metroPort: metroPort() ?? "unknown",
-			publicUrl: env["STIM_METRO_PUBLIC_URL"]?.trim() || publicUrl,
-			isExpo,
-			available: detectProviders(onPath, mode)
-		});
-		if ("failed" in plan) return unusable("eas-metro-unreachable", plan.failed);
-		if ("start" in plan && plan.start === "tailscale") return unusable("eas-metro-unreachable", "metro.tunnel is tailscale, which an EAS Simulator cannot reach");
-		if ("expoTunnel" in plan && readTunnel(root)?.kind !== "expo") return unusable("eas-metro-unreachable", "Metro has no Expo tunnel; run stim start --remote first");
-	}
-	return parseSimulatorAvailability(await availability(bin.file));
-}
-//#endregion
-//#region src/engine/metro-warmup.ts
-const WARMUP_TIMEOUT_MS = 6e4;
-async function requestLocal(url, platform, prefetch) {
-	return new Promise((resolve) => {
-		const req = request(url, { headers: {
-			accept: "application/json",
-			"expo-platform": platform,
-			...prefetch ? { "x-stim-metro-warmup": "1" } : {}
-		} });
-		const timer = setTimeout(() => req.destroy(), WARMUP_TIMEOUT_MS);
-		timer.unref();
-		req.on("socket", (socket) => socket.unref());
-		req.on("error", () => resolve(null));
-		req.on("close", () => {
-			clearTimeout(timer);
-			resolve(null);
-		});
-		req.on("response", (res) => {
-			let body = "";
-			res.setEncoding("utf8");
-			res.on("data", (chunk) => {
-				if (!prefetch) body += chunk;
-			});
-			res.on("error", () => resolve(null));
-			res.on("end", () => resolve(res.statusCode === 200 ? body : null));
-		});
-		req.end();
-	});
-}
-async function warmMetro({ port, platform, isExpo, appId, bundleUrl }) {
-	try {
-		const origin = `http://127.0.0.1:${port}`;
-		if (await requestLocal(new URL("/_stim/metro-warmup", origin), platform, false) !== "ready") return;
-		const url = new URL("/index.bundle", origin);
-		url.search = new URLSearchParams({
-			platform,
-			dev: "true",
-			lazy: "true",
-			minify: "false",
-			...platform === "ios" ? { inlineSourceMap: "false" } : {},
-			modulesOnly: "false",
-			runModule: "true",
-			excludeSource: "true",
-			sourcePaths: "url-server",
-			...appId ? { app: appId } : {}
-		}).toString();
-		if (!bundleUrl && isExpo) {
-			const body = await requestLocal(new URL(origin), platform, false);
-			if (body === null) return;
-			const manifest = JSON.parse(body);
-			bundleUrl = manifest.launchAsset?.url ?? manifest.bundleUrl;
-			if (typeof bundleUrl !== "string") return;
-		}
-		if (bundleUrl) {
-			const bundle = new URL(bundleUrl, origin);
-			url.pathname = bundle.pathname;
-			url.search = bundle.search;
-		}
-		await requestLocal(url, platform, true);
-	} catch {}
-}
-//#endregion
-//#region src/engine/android-avd-setup.ts
-var AvdBootError = class extends Error {
-	remedy;
-	constructor(message, remedy, cause) {
-		super(message, { cause });
-		this.remedy = remedy;
-	}
-};
-var AvdRecoveryError = class extends AvdBootError {};
-function findOtherOwner(avdName, projectPath, selectedSlot = "default") {
-	for (const [path, project] of Object.entries(loadConfig$1()?.projects ?? {})) if (projectDeviceSlots(project).some(({ slot, platforms }) => (path !== projectPath || slot !== selectedSlot) && platforms.android?.avdName?.toLowerCase() === avdName.toLowerCase())) return path;
-	return null;
-}
-async function prepareOwnedAvd({ projectPath, slot, label, previousAvdName, systemImage, deviceProfile, configuration, configure, teardown = teardownOwnedAvd }) {
-	const { claim, reservation, previous, avdName } = withConfigLock$1(() => {
-		const previous = deviceSlotPlatforms(loadConfig$1()?.projects?.[projectPath], slot)?.android;
-		if (previous?.avdName && previous.avdName !== previousAvdName) throw new Error(`Another Stim run assigned AVD ${previous.avdName} to this workspace. Retry to use it.`);
-		if (readParked("android").some((entry) => entry.name === ownedAvdName(label)) || findOtherOwner(ownedAvdName(label), projectPath, slot)) label = `${label}-${randomUUID().slice(0, 8)}`;
-		const avdName = ownedAvdName(label);
-		const claim = acquireAvdClaim(avdName);
-		const reservation = {
-			avdName,
-			owned: true,
-			deviceName: avdName,
-			setupIncomplete: true,
-			poolConfiguration: configuration
-		};
-		try {
-			setDevice(projectPath, "android", reservation, slot);
-			return {
-				claim,
-				reservation,
-				previous,
-				avdName
-			};
-		} catch (error) {
-			releaseClaim(claim);
-			throw error;
-		}
-	});
-	const currentRecord = () => deviceSlotPlatforms(loadConfig$1()?.projects?.[projectPath], slot)?.android;
-	const assertReservation = () => {
-		if (readParked("android").some((entry) => entry.name === avdName)) throw new Error(`AVD ${avdName} was parked by another Stim run. Retry to adopt it safely.`);
-		const owner = findOtherOwner(avdName, projectPath, slot);
-		if (owner) throw new Error(`AVD ${avdName} already exists and is owned by another project (${owner}). Retry to allocate a distinct owned emulator.`);
-		const current = currentRecord();
-		if (!isDeepStrictEqual(current, reservation)) {
-			const state = current?.setupIncomplete ? "has incomplete setup" : "was registered or removed";
-			throw new Error(`AVD ${current?.avdName ?? avdName} ${state} by another concurrent Stim run. Retry after that run finishes so the recorded device is resolved safely.`);
-		}
-	};
-	let prepared;
-	let child;
-	const creationRunning = () => child?.pid !== void 0 && processGroupAlive(child.pid);
-	let configurationFailure;
-	try {
-		try {
-			const creation = await createOwnedAvd(label, {
-				systemImage,
-				deviceProfile,
-				spawn: (...args) => {
-					markClaimChildPending(claim);
-					child = getExecutor().spawn(...args);
-					if (child.pid !== void 0) {
-						const captured = captureProcessIdentity(child.pid);
-						if (captured.ok) try {
-							setClaimChild(claim, {
-								pid: child.pid,
-								processToken: captured.token
-							});
-						} catch {}
-					}
-					return child;
-				}
-			}).then((result) => ({ result }), (error) => ({ error }));
-			if (creationRunning()) throw new AvdRecoveryError(`AVD ${avdName} creation left its process group running (pid ${child.pid}); its reservation remains incomplete.`, `Wait for process group ${child.pid} to finish before retrying stim android. If its identity could not be recorded, inspect the group and remove the claim only after it stops: ${claimRemoveCommand(claim.path)}`);
-			clearClaimChild(claim);
-			if ("error" in creation) throw creation.error;
-			prepared = {
-				...creation.result,
-				created: true
-			};
-		} catch (error) {
-			const message = String(error?.message || error);
-			if (!message.includes("already exists")) throw error;
-			try {
-				if (!listAvds().includes(avdName)) throw new AvdRecoveryError(`AVD ${avdName} already exists on disk but is not listed by the emulator. ${message}`, "Run `npx stim gc` to inspect orphaned owned AVDs, then `npx stim gc --delete` to reclaim those safe to delete. Retry `stim android` after cleanup; keep any AVD that GC cannot verify.", error);
-				withConfigLock$1(assertReservation);
-				const resolved = resolveOwnedAvdSerial(avdName);
-				if (resolved.missing || resolved.notOwned) throw new Error(`AVD ${avdName} could not be verified for recovery. Retry after checking its registration.`, { cause: error });
-				if (!resolved.serial) assertOwnedAvdStopped(avdName);
-				prepared = {
-					avdName,
-					created: false,
-					systemImage: ownedAvdSystemImage(avdName),
-					deviceProfile: ownedAvdDeviceProfile(avdName),
-					...resolved.serial ? {
-						serial: resolved.serial,
-						consolePort: Number(resolved.serial.replace(/^emulator-/, ""))
-					} : {}
-				};
-			} catch (recoveryError) {
-				withConfigLock$1(() => {
-					if (!isDeepStrictEqual(currentRecord(), reservation)) return;
-					if (previous) setDevice(projectPath, "android", previous, slot);
-					else clearDevice(projectPath, "android", slot, avdName);
-				});
-				if (recoveryError instanceof AvdRecoveryError) throw recoveryError;
-				throw new AvdRecoveryError(`Could not recover owned AVD ${avdName}: ${String(recoveryError?.message || recoveryError)}`, "Inspect `npx stim status` and `adb devices`. Wait for any other Stim run using this AVD to finish, then retry `stim android`. Keep the AVD and its process locks while its state is unverified.", recoveryError);
-			}
-		}
-		if (prepared.created) try {
-			configure(avdName);
-		} catch (error) {
-			configurationFailure = { error };
-		}
-		if (!configurationFailure) withConfigLock$1(() => {
-			assertReservation();
-			setDevice(projectPath, "android", {
-				avdName,
-				owned: true,
-				deviceName: avdName,
-				...prepared.created ? {
-					poolConfiguration: configuration,
-					bootPending: true
-				} : {},
-				...prepared.consolePort ? { consolePort: prepared.consolePort } : {}
-			}, slot);
-		});
-	} finally {
-		if (!creationRunning()) releaseClaim(claim);
-		else {
-			child?.stdout?.destroy();
-			child?.stderr?.destroy();
-			child?.unref();
-		}
-	}
-	if (configurationFailure) {
-		const { error } = configurationFailure;
-		const cleanup = teardown(avdName, {
-			del: true,
-			owner: {
-				projectPath,
-				slot,
-				expectedRecord: reservation
-			},
-			onRemoved: () => {
-				clearDevice(projectPath, "android", slot, avdName);
-			}
-		});
-		const orphan = cleanup.status === "failed" || cleanup.status === "skipped" ? ` The owned AVD remains tracked for cleanup (${cleanup.reason || cleanup.status}); fix the cause, then retry or run \`stim gc --delete\`.` : "";
-		throw new Error(`Created owned AVD ${avdName}, but could not configure its AVD settings: ${String(error?.message || error)}${orphan}`, { cause: error });
-	}
-	return prepared;
-}
-//#endregion
-//#region src/engine/device-android.ts
-const ANDROID_FRESH_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 12e4;
-const ANDROID_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 24e4;
-async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, logFile, alive, configureAvd, teardownAvd }) {
-	const projectAvdConfig = androidAvdConfigSetting(settings, settingsRoot);
-	const avdConfig = {
-		...OWNED_AVD_CONFIG_DEFAULTS,
-		...projectAvdConfig
-	};
-	const requestedProfile = flags.deviceProfile || settings.android?.deviceProfile || null;
-	let replacedProfile = null;
-	if (record?.setupIncomplete && record.avdName) {
-		const avdName = record.avdName;
-		const cleanup = teardownAvd(avdName, {
-			del: true,
-			owner: {
-				projectPath,
-				slot,
-				expectedRecord: record
-			},
-			onRemoved: () => {
-				clearDevice(projectPath, "android", slot, avdName);
-			}
-		});
-		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new AvdRecoveryError(`Owned AVD ${record.avdName} has incomplete setup and could not be deleted (${cleanup.reason || cleanup.status}). Fix the cause, then retry; Stim kept the device record for cleanup.`, "Wait for any active AVD operation to finish. If the refusal names an unresolved claim, inspect its creator and native processes before removing only that claim. Retry `stim android` to reconcile the incomplete device.");
-		record = null;
-	}
-	const requestedImage = flags.systemImageFlag || null;
-	const currentImage = requestedImage && record?.owned && record.avdName ? ownedAvdSystemImage(record.avdName) : null;
-	if (record?.avdName && requestedImage && currentImage && currentImage !== requestedImage) {
-		const avdName = record.avdName;
-		if (!record.bootPending) throw new AvdRecoveryError(`this project's emulator ${avdName} uses system image ${currentImage}, but ${requestedImage} was requested. --system-image replaces only an emulator that never finished a boot, and this one has.`, "Run `stim worktree remove` (or `stim gc --delete`) to reap the current emulator, then `stim android` again to create the requested one, or pass `--slot <name>` to create it beside the current one.");
-		replacedProfile = ownedAvdDeviceProfile(avdName);
-		const cleanup = teardownAvd(avdName, {
-			del: true,
-			owner: {
-				projectPath,
-				slot,
-				expectedRecord: record
-			},
-			onRemoved: () => {
-				clearDevice(projectPath, "android", slot, avdName);
-			}
-		});
-		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new AvdRecoveryError(`Owned AVD ${avdName} never finished a boot, but could not be deleted to create one on ${requestedImage} (${cleanup.reason || cleanup.status}). Stim kept the device record.`, "Fix the cause, then retry, or pass `--slot <name>` to create the requested emulator beside it.");
-		out(phaseLine("device", `deleted ${avdName}, which never finished a boot, to create one on ${requestedImage}`));
-		record = null;
-	}
-	const deviceProfile = requestedProfile ?? replacedProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
-	const configuration = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), avdConfig, deviceProfile);
-	const configurationBeforeDefaults = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), projectAvdConfig, deviceProfile);
-	if (record?.avdName) {
-		if (record.owned) {
-			const resolved = resolveOwnedAvdSerial(record.avdName);
-			const currentProfile = resolved.notOwned || resolved.missing ? null : ownedAvdDeviceProfile(record.avdName);
-			if (requestedProfile && currentProfile && currentProfile !== requestedProfile) throw new AvdRecoveryError(`this project's emulator uses device profile ${currentProfile}, but ${requestedProfile} was requested. Stim will not silently boot a different model.`, "Run `stim worktree remove` (or `stim gc --delete`) to reap the current emulator, then `stim android` again to create the requested one, or pass `--slot <name>` to create it beside the current one.");
-			if (resolved.notOwned) note(chalk.yellow(`Note: recorded AVD ${record.avdName} is not Stim-owned -- creating a fresh owned AVD instead of reusing it.`));
-			else if (resolved.serial) {
-				const consolePort = Number(resolved.serial.replace(/^emulator-/, ""));
-				if (record.consolePort && record.consolePort !== consolePort) out(phaseLine("device", `${record.avdName} changed serial (emulator-${record.consolePort} -> ${resolved.serial}); reconnecting this run, reopen agent-device on ${resolved.serial}`));
-				const updated = {
-					...record,
-					avdName: record.avdName,
-					consolePort,
-					owned: true,
-					deviceName: record.deviceName ?? record.avdName
-				};
-				setDevice(projectPath, "android", updated, slot);
-				return {
-					...updated,
-					systemImage: ownedAvdSystemImage(record.avdName),
-					deviceProfile: currentProfile
-				};
-			} else if (!resolved.missing) {
-				out(chalk.dim(`Recorded port for owned AVD ${record.avdName} is not currently ours; booting it on a freshly allocated port...`));
-				return {
-					...await bootOwnedAvdOnFreshPort({
-						deviceSlotWait: flags.deviceSlotWait,
-						avdName: record.avdName,
-						metadata: record,
-						projectPath,
-						slot,
-						deviceName: record.deviceName,
-						out,
-						logFile,
-						alive
-					}),
-					systemImage: ownedAvdSystemImage(record.avdName),
-					deviceProfile: currentProfile
-				};
-			}
-		} else if (listAvds().includes(record.avdName)) {
-			if (!listAdbDevices().emulators.some((e) => e.consolePort === record.consolePort)) {
-				note(chalk.yellow(`Note: assigned AVD ${record.avdName} (emulator-${record.consolePort}) is shut down and is not owned by Stim, so it will not be booted automatically.`));
-				note(chalk.dim("Boot it yourself, or run `stim gc --delete` to clear the assignment so Stim can create an owned AVD."));
-			}
-			return record;
-		}
-	} else if (record?.serial) {
-		note(chalk.yellow(`Note: this project has a stored assignment to physical device ${record.serial}, which Stim no longer keeps.`));
-		note(chalk.dim("Creating an owned emulator instead. Pass `--device` to build for a connected device."));
-	}
-	if (parkedMaxSetting("android").max > 0) {
-		const systemImage = pickDefaultSystemImage(listInstalledSystemImages(), { systemImage: flags.systemImage || settings.android?.systemImage })?.pkg;
-		const candidates = readParked("android").filter((entry) => entry.systemImage === systemImage && (entry.configuration === configuration || entry.configuration === configurationBeforeDefaults)).toSorted((a, b) => a.parkedAt.localeCompare(b.parkedAt));
-		for (const parked of candidates) {
-			if (isLegacyDeletionClaim(parked.deletionClaim)) continue;
-			const resolved = resolveOwnedAvdSerial(parked.name);
-			if (resolved.missing) {
-				const result = teardownParkedAvd(parked.name);
-				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
-				continue;
-			}
-			if (resolved.notOwned || resolved.serial) continue;
-			try {
-				assertOwnedAvdStopped(parked.name);
-			} catch (error) {
-				out(phaseLine("device", `kept parked ${parked.name}: ${String(error?.message || error)}`));
-				continue;
-			}
-			if (ownedAvdSystemImage(parked.name) !== systemImage || !ownedAvdMatchesConfiguration(parked.name, parked.configuration)) {
-				const result = teardownParkedAvd(parked.name);
-				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
-				continue;
-			}
-			const adopted = {
-				avdName: parked.name,
-				deviceName: parked.name,
-				owned: true,
-				poolConfiguration: parked.configuration,
-				adoptionPending: true
-			};
-			if (!adoptParked({
-				platform: "android",
-				projectPath,
-				slot,
-				udid: parked.udid,
-				device: adopted
-			})) continue;
-			if (parked.configuration !== configuration) try {
-				configureAvd(parked.name, {
-					dataPartitionSizeGb: androidDataPartitionSizeGbSetting(settings),
-					avdConfig
-				});
-				adopted.poolConfiguration = configuration;
-			} catch (error) {
-				out(phaseLine("device", `${parked.name} keeps its old AVD settings: ${String(error?.message || error)}`));
-			}
-			return {
-				...await bootOwnedAvdOnFreshPort({
-					deviceSlotWait: flags.deviceSlotWait,
-					avdName: parked.name,
-					projectPath,
-					slot,
-					metadata: adopted,
-					out,
-					logFile,
-					alive
-				}),
-				adopted: true,
-				systemImage,
-				deviceProfile
-			};
-		}
-	}
-	const created = await prepareOwnedAvd({
-		projectPath,
-		slot,
-		label,
-		previousAvdName: record?.avdName,
-		systemImage: flags.systemImage || settings.android?.systemImage || void 0,
-		deviceProfile,
-		configuration,
-		configure: (avdName) => configureAvd(avdName, {
-			dataPartitionSizeGb: androidDataPartitionSizeGbSetting(settings),
-			avdConfig
-		}),
-		teardown: teardownAvd
-	});
-	if (!created.created) {
-		out(chalk.dim(phaseLine("device", `recovered ${created.avdName} (unrecorded from a prior run)`)));
-		if (created.serial) return {
-			...created,
-			owned: true,
-			deviceName: created.avdName
-		};
-	}
-	return {
-		...await bootOwnedAvdOnFreshPort({
-			deviceSlotWait: flags.deviceSlotWait,
-			avdName: created.avdName,
-			metadata: created.created ? {
-				poolConfiguration: configuration,
-				bootPending: true
-			} : void 0,
-			projectPath,
-			slot,
-			deviceName: created.avdName,
-			out,
-			logFile,
-			alive
-		}),
-		created: created.created,
-		systemImage: created.systemImage,
-		deviceProfile: created.deviceProfile
-	};
-}
-function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock$1, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
-	return lock(() => {
-		const consolePort = nextConsolePort([...recordedPorts(), ...livePorts]);
-		const claim = {
-			...metadata?.poolConfiguration ? { poolConfiguration: metadata.poolConfiguration } : {},
-			...metadata?.adoptionPending ? { adoptionPending: true } : {},
-			...metadata?.bootPending ? { bootPending: true } : {},
-			avdName,
-			consolePort,
-			owned: true,
-			deviceName: deviceName ?? avdName
-		};
-		record(projectPath, "android", claim, slot);
-		return claim;
-	});
-}
-function liveAndroidConsolePorts() {
-	const adbLive = listAdbDevices();
-	return [...adbLive.emulators.map((e) => e.consolePort), ...adbLive.unhealthy.map((u) => u.consolePort).filter((p) => p != null)];
-}
-async function bootOwnedAvdOnFreshPort({ avdName, deviceSlotWait, metadata, projectPath, slot, deviceName, out, logFile = null, alive = pidExists }) {
-	return withDeviceBootAdmission({
-		platform: "android",
-		key: avdName
-	}, async () => {
-		const claim = claimAndroidConsolePort({
-			projectPath,
-			slot,
-			avdName,
-			deviceName,
-			livePorts: liveAndroidConsolePorts(),
-			metadata
-		});
-		const serial = `emulator-${claim.consolePort}`;
-		try {
-			reportAndroidMemoryPressure(out);
-			const pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
-			out(chalk.dim(phaseLine("device", `waiting for ${serial} to finish booting`)));
-			const result = await waitForAndroidBoot({
-				serial,
-				timeoutMs: ANDROID_FRESH_BOOT_TIMEOUT_MS,
-				pid,
-				alive,
-				out
-			});
-			if (result.failed) throw new AvdBootError(result.reason, result.remedy);
-			const running = getAvdNameForSerial(serial);
-			if (running && running !== avdName) throw new Error(`${serial} is running AVD ${running}, not this workspace's owned AVD ${avdName}; refusing to use it.`);
-			clearAndroidBootPending(projectPath, avdName, slot);
-			const { bootPending: _booted, ...booted } = claim;
-			return {
-				...booted,
-				serial,
-				setup: true
-			};
-		} catch (error) {
-			releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-			throw error;
-		}
-	}, {
-		...deviceSlotWait,
-		root: projectPath,
-		out
-	});
-}
-function reportAndroidMemoryPressure(out) {
-	const pressure = readHostMemoryPressure();
-	if (pressure === "warning" || pressure === "critical") out(chalk.dim(phaseLine("memory", `macOS reports ${pressure} host memory pressure; emulator boot may be slow. Free memory with \`stim stop\` only in workspaces you own; ask before closing other apps or devices.`)));
-}
-function androidBootRemedy(pressure) {
-	let count = null;
-	try {
-		const live = countLiveOwnedDevices({
-			sims: () => process.platform === "darwin" ? listAllIosSims({ timeoutMs: 2e3 }) : [],
-			adb: () => ({
-				...listAdbDevices({ timeoutMs: 2e3 }),
-				unhealthy: []
-			}),
-			booting: []
-		});
-		count = typeof live === "number" ? live : null;
-	} catch {}
-	const observation = pressure === "warning" || pressure === "critical" ? `macOS reports ${pressure} host memory pressure. ` : "";
-	const devices = count ? `${count} Stim-owned ${count === 1 ? "device is" : "devices are"} running. ` : "";
-	if (observation || devices) return `${observation}${devices}Stop an unneeded device with \`stim stop\` only in a workspace you own, then run \`stim android\` again; ask before closing other apps or devices. These observations do not establish the cause of the timeout or an OOM crash.`;
-	return "Inspect the emulator log and run `stim doctor` to check JAVA_HOME, ANDROID_HOME, and installed system images, then run `stim android` again.";
-}
-async function waitForAndroidBoot({ serial, timeoutMs, pid = null, alive = pidExists, out }) {
-	const aborted = () => pid !== null && !alive(pid);
-	const wait = (windowMs) => waitForBoot(serial, windowMs, {
-		aborted,
-		commandTimeoutMs: 5e3
-	});
-	let result = await wait(timeoutMs);
-	if (result.ok) return {
-		ok: true,
-		serial
-	};
-	let pressure = readHostMemoryPressure();
-	let elapsedMs = timeoutMs;
-	if (!result.exited && pid !== null && !aborted() && (pressure === "warning" || pressure === "critical")) {
-		const extensionMs = 24e4;
-		out(chalk.dim(phaseLine("memory", `macOS reports ${pressure} host memory pressure; retrying the boot wait once for the same live emulator ${serial} (up to ${extensionMs / 1e3}s more).`)));
-		result = await wait(extensionMs);
-		if (result.ok) return {
-			ok: true,
-			serial
-		};
-		elapsedMs += extensionMs;
-		pressure = readHostMemoryPressure();
-	}
-	const exited = result.exited || aborted();
-	return {
-		failed: true,
-		reason: `${exited ? `The emulator process for ${serial} exited before the device finished booting.` : `Emulator ${serial} did not finish booting within ${Math.round(elapsedMs / 1e3)}s.`} Diagnostic: ${JSON.stringify(result.diagnostic)}`,
-		remedy: exited ? "Inspect the emulator log for the process exit, fix what it reports, then run `stim android` again." : androidBootRemedy(pressure)
-	};
-}
-async function ensureAndroidBooted({ device, deviceSlotWait, projectPath, slot, timeoutMs, out, logFile = null, alive = pidExists }) {
-	if (!device?.avdName || !projectPath) return {
-		failed: true,
-		reason: "No owned Android emulator is recorded for this project."
-	};
-	let resolved;
-	try {
-		resolved = resolveOwnedAvdSerial(device.avdName);
-	} catch (e) {
-		return {
-			failed: true,
-			reason: `Could not list AVDs: ${e?.message || e}`
-		};
-	}
-	if (resolved.missing) return {
-		failed: true,
-		reason: `AVD ${device.avdName} no longer exists. Run \`stim android\` again to create a fresh owned AVD.`
-	};
-	if (resolved.notOwned) return {
-		failed: true,
-		reason: `AVD ${device.avdName} is not Stim-owned; refusing to boot it.`
-	};
-	const avdName = device.avdName;
-	const booted = (result) => {
-		if (!result.failed) clearAndroidBootPending(projectPath, avdName, slot);
-		return result;
-	};
-	if (resolved.serial) return booted(await waitForAndroidBoot({
-		serial: resolved.serial,
-		timeoutMs,
-		out
-	}));
-	const freshSerial = `emulator-${device.consolePort}`;
-	if (device.owned && device.serial === freshSerial) return booted(await waitForAndroidBoot({
-		serial: freshSerial,
-		timeoutMs,
-		out
-	}));
-	const boot = async () => {
-		const claim = claimAndroidConsolePort({
-			projectPath,
-			slot,
-			avdName,
-			deviceName: device.deviceName,
-			livePorts: liveAndroidConsolePorts(),
-			metadata: device
-		});
-		const serial = `emulator-${claim.consolePort}`;
-		reportAndroidMemoryPressure(out);
-		out(chalk.dim(phaseLine("device", `booting ${avdName} as ${serial}`)));
-		let pid = null;
-		try {
-			pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
-		} catch (e) {
-			releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-			return {
-				failed: true,
-				reason: `Could not start emulator for AVD ${avdName}: ${e?.message || e}`
-			};
-		}
-		const result = await waitForAndroidBoot({
-			serial,
-			timeoutMs,
-			pid,
-			alive,
-			out
-		});
-		if (result.failed) releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-		return booted(result);
-	};
-	try {
-		return await withDeviceBootAdmission({
-			platform: "android",
-			key: avdName
-		}, boot, {
-			...deviceSlotWait,
-			root: projectPath,
-			out
-		});
-	} catch (error) {
-		const refusal = error instanceof DeviceAdmissionRefusal ? error : (0, ownership_claim_exports.claimFailure)(error, "stim android");
-		if (!refusal) throw error;
-		return {
-			failed: true,
-			code: refusal.code,
-			reason: refusal.message,
-			remedy: refusal.remedy
-		};
-	}
-}
-//#endregion
-//#region src/engine/device.ts
-/**
-* Whether `ensureOwnedDevice` created, adopted or started booting the device, rather than finding it booted.
-* Undefined for a remote device, which those functions do not describe.
-*/
-function didSetUpDevice(device, remote) {
-	return remote ? void 0 : Boolean(device.setup || device.booting);
-}
-async function ensureOwnedDevice({ platform, project, projectPath, slot, settingsRoot = projectPath, label = ownedDeviceLabel(projectPath), settings, flags = {}, note = () => {}, out = () => {}, logFile = null, alive = pidExists, configureAvd = configureNewOwnedAvd, teardownAvd = teardownOwnedAvd, reconcileIosSimulator = reconcileSimSlim, simSnapshot }) {
-	clearDeviceIdleShutdown(projectPath, platform, slot);
-	if (slot && slot !== "default") label = `${label}-${slot}`;
-	const record = deviceSlotPlatforms(project, slot)?.[platform] ?? null;
-	if (platform === "ios") return ensureOwnedIosDevice({
-		record,
-		projectPath,
-		slot,
-		settingsRoot,
-		label,
-		settings,
-		flags,
-		note,
-		out,
-		reconcileIosSimulator,
-		simSnapshot
-	});
-	return ensureOwnedAndroidDevice({
-		record,
-		projectPath,
-		slot,
-		settingsRoot,
-		label,
-		settings,
-		flags,
-		note,
-		out,
-		logFile,
-		alive,
-		configureAvd,
-		teardownAvd
-	});
-}
-const BOOT_POLL_MS = 500;
-async function ensureBooted({ platform, device, simulatorApp, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists, projectPath, slot, deviceSlotWait }) {
-	if (platform === "ios") return ensureIosBooted({
-		device,
-		projectPath,
-		deviceSlotWait,
-		simulatorApp,
-		timeoutMs: timeoutMs ?? 6e5,
-		pollMs,
-		out
-	});
-	if (platform === "android") return ensureAndroidBooted({
-		device,
-		deviceSlotWait,
-		projectPath,
-		slot,
-		timeoutMs: timeoutMs ?? ANDROID_BOOT_TIMEOUT_MS,
-		out,
-		logFile,
-		alive
-	});
-	return {
-		failed: true,
-		reason: `Unknown platform "${platform}".`
-	};
-}
-//#endregion
-//#region src/engine/js-swap.ts
-const JS_BUNDLE_NAME = "main.jsbundle";
-const LAST_LINES = 5;
-function hermesEnabledFromProperties(text) {
-	if (typeof text !== "string") return true;
-	let data;
-	try {
-		data = JSON.parse(text);
-	} catch {
-		return true;
-	}
-	if (!data || typeof data !== "object") return true;
-	const raw = data.hermesEnabled;
-	return raw !== "false" && raw !== false;
-}
-function readHermesEnabled(root) {
-	try {
-		return hermesEnabledFromProperties(readFileSync(join(root, "ios", "Podfile.properties.json"), "utf-8"));
-	} catch {
-		return true;
-	}
-}
-const ENTRY_CANDIDATES = [
-	"index.js",
-	"index.ts",
-	"index.tsx",
-	"index.jsx"
-];
-function pickEntryFile(entries) {
-	const names = new Set((Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string"));
-	return ENTRY_CANDIDATES.find((c) => names.has(c)) ?? "index.js";
-}
-function detectEntryFile(root) {
-	let entries;
-	try {
-		entries = readdirSync(root);
-	} catch {
-		return "index.js";
-	}
-	return pickEntryFile(entries);
-}
-function bundleCommand({ isExpo, entryFile, bundleOutput, assetsDest, assetCatalogDest = null }) {
-	const catalogArgs = assetCatalogDest ? ["--asset-catalog-dest", assetCatalogDest] : [];
-	if (isExpo) return {
-		file: "npx",
-		args: [
-			"expo",
-			"export:embed",
-			"--platform",
-			"ios",
-			"--dev",
-			"false",
-			"--bundle-output",
-			bundleOutput,
-			"--assets-dest",
-			assetsDest,
-			...catalogArgs
-		]
-	};
-	return {
-		file: "npx",
-		args: [
-			"react-native",
-			"bundle",
-			"--platform",
-			"ios",
-			"--dev",
-			"false",
-			"--entry-file",
-			entryFile,
-			"--bundle-output",
-			bundleOutput,
-			"--assets-dest",
-			assetsDest,
-			...catalogArgs
-		]
-	};
-}
-const ASSET_CATALOG_BUNDLE = "RNAssets.bundle";
-/**
-* Where React Native 0.88+ keeps the app's packager images. With the `RCTUseAssetCatalog` Info.plist
-* key, `react-native-xcode.sh` compiles them with actool into RNAssets.bundle and the native image
-* loader reads only that catalog, so a swap has to rebuild it. Null means loose files under assets/.
-*/
-function assetCatalogTarget(infoPlist) {
-	if (!infoPlist || typeof infoPlist !== "object") return null;
-	const plist = infoPlist;
-	const flag = plist.RCTUseAssetCatalog;
-	if (!(flag === true || flag === 1 || typeof flag === "string" && [
-		"true",
-		"yes",
-		"1"
-	].includes(flag.toLowerCase()))) return null;
-	const families = Array.isArray(plist.UIDeviceFamily) ? plist.UIDeviceFamily : [1];
-	const targetDevices = [...families.includes(1) ? ["iphone"] : [], ...families.includes(2) ? ["ipad"] : []];
-	return {
-		platform: typeof plist.DTPlatformName === "string" ? plist.DTPlatformName : "iphoneos",
-		minimumDeploymentTarget: typeof plist.MinimumOSVersion === "string" ? plist.MinimumOSVersion : "15.1",
-		targetDevices: targetDevices.length ? targetDevices : ["iphone"]
-	};
-}
-function readPlistKey(e, plist, key, format) {
-	try {
-		return e.runFile("plutil", [
-			"-extract",
-			key,
-			format,
-			"-o",
-			"-",
-			plist
-		]);
-	} catch (err) {
-		if (/No value at that key path/.test(describe(err))) return null;
-		throw err;
-	}
-}
-function readAssetCatalogTarget(e, plist) {
-	const flag = readPlistKey(e, plist, "RCTUseAssetCatalog", "raw");
-	if (flag === null) return null;
-	const families = readPlistKey(e, plist, "UIDeviceFamily", "json");
-	return assetCatalogTarget({
-		RCTUseAssetCatalog: flag,
-		DTPlatformName: readPlistKey(e, plist, "DTPlatformName", "raw"),
-		MinimumOSVersion: readPlistKey(e, plist, "MinimumOSVersion", "raw"),
-		UIDeviceFamily: families === null ? void 0 : JSON.parse(families)
-	});
-}
-function actoolArgs({ catalog, out, target }) {
-	return [
-		"actool",
-		catalog,
-		"--compile",
-		out,
-		"--output-format",
-		"human-readable-text",
-		"--errors",
-		"--warnings",
-		"--notices",
-		"--platform",
-		target.platform,
-		"--minimum-deployment-target",
-		target.minimumDeploymentTarget,
-		...target.targetDevices.flatMap((device) => ["--target-device", device])
-	];
-}
-const ASSET_CATALOG_BUNDLE_INFO_PLIST = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>CFBundleIdentifier</key>
-  <string>org.reactjs.RNAssets</string>
-  <key>CFBundleInfoDictionaryVersion</key>
-  <string>6.0</string>
-  <key>CFBundleName</key>
-  <string>RNAssets</string>
-  <key>CFBundlePackageType</key>
-  <string>BNDL</string>
-</dict>
-</plist>
-`;
-const UPDATES_MANIFEST_NAME = "app.manifest";
-/**
-* expo-updates launches the update with the newest `commitTime` among those built for the binary's
-* runtime version, and the embedded one is only a row in that race. A swapped copy keeps the id and
-* `commitTime` the cached build wrote, so an update downloaded after that build would launch instead
-* of the injected bundle. A full build writes a fresh id and `commitTime`; this does the same.
-*/
-function refreshUpdatesManifest(text, { id, commitTime }) {
-	const manifest = JSON.parse(text);
-	if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error(`${UPDATES_MANIFEST_NAME} is not a JSON object`);
-	return JSON.stringify({
-		...manifest,
-		id,
-		commitTime
-	});
-}
-function refreshUpdatesManifestFile(path, commitTime) {
-	writeFileSync(path, refreshUpdatesManifest(readFileSync(path, "utf-8"), {
-		id: randomUUID(),
-		commitTime
-	}));
-}
-const IOS_UPDATES_MANIFESTS = [join("EXUpdates.bundle", UPDATES_MANIFEST_NAME), UPDATES_MANIFEST_NAME];
-const IOS_FRAMEWORK_UPDATES_MANIFEST = join("Frameworks", "EXUpdates.framework", "EXUpdates.bundle", UPDATES_MANIFEST_NAME);
-function hermescPath(root, { exists = existsSync } = {}) {
-	const candidates = [
-		join(root, "node_modules", "hermes-compiler", "hermesc", "osx-bin", "hermesc"),
-		join(root, "ios", "Pods", "hermes-engine", "destroot", "bin", "hermesc"),
-		join(root, "node_modules", "react-native", "sdks", "hermesc", "osx-bin", "hermesc")
-	];
-	return candidates.find(exists) ?? candidates[candidates.length - 1];
-}
-function hermescArgs({ bundle, out }) {
-	return [
-		"-emit-binary",
-		"-out",
-		out,
-		bundle
-	];
-}
-async function swapJsBundle({ root, isExpo, cachedAppPath, logWriter = null, exec = null, spawnFn = null, mkdtemp = () => makeTemporaryDirectory(cachedAppPath, "stim-js-swap-"), exists = existsSync, hermesEnabled = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, onHeartbeat = (line) => console.error(line) }) {
-	const e = exec || getExecutor();
-	const startedAt = now();
-	const elapsed = () => now() - startedAt;
-	let tmp;
-	const fail = (step, reason, lastLines = []) => {
-		logWriter?.write?.({
-			src: "build",
-			level: "error",
-			msg: `JS swap failed at ${step}: ${reason}`,
-			event: "js_swap"
-		});
-		if (tmp) removeTemporaryEntry(tmp);
-		return {
-			failed: true,
-			step,
-			reason,
-			lastLines,
-			durationMs: elapsed()
-		};
-	};
-	let appCopy;
-	try {
-		tmp = mkdtemp();
-		appCopy = join(tmp, basename(cachedAppPath));
-		try {
-			e.runFile("cp", [
-				"-c",
-				"-R",
-				cachedAppPath,
-				appCopy
-			]);
-		} catch {
-			removeTemporaryEntry(appCopy);
-			e.runFile("cp", [
-				"-R",
-				cachedAppPath,
-				appCopy
-			]);
-		}
-	} catch (err) {
-		return fail("copy", `could not copy ${cachedAppPath} aside: ${describe(err)}`);
-	}
-	let catalogTarget;
-	const infoPlistPath = join(appCopy, "Info.plist");
-	try {
-		catalogTarget = readAssetCatalogTarget(e, infoPlistPath);
-	} catch (err) {
-		return fail("catalog", `could not read ${infoPlistPath}: ${describe(err)}`);
-	}
-	const bundleOutput = join(tmp, JS_BUNDLE_NAME);
-	const assetsDest = join(tmp, "assets");
-	const catalogStaging = catalogTarget ? join(tmp, "rn-assets") : null;
-	const catalogDir = catalogStaging ? join(catalogStaging, "RNAssets.xcassets") : null;
-	const command = bundleCommand({
-		isExpo,
-		entryFile: isExpo ? "index.js" : detectEntryFile(root),
-		bundleOutput,
-		assetsDest,
-		assetCatalogDest: catalogStaging
-	});
-	try {
-		mkdirSync(assetsDest, { recursive: true });
-	} catch (err) {
-		return fail("bundle", `could not create ${assetsDest}: ${describe(err)}`);
-	}
-	if (catalogDir) try {
-		mkdirSync(catalogDir, { recursive: true });
-	} catch (err) {
-		return fail("bundle", `could not create ${catalogDir}: ${describe(err)}`);
-	}
-	logWriter?.write?.({
-		src: "build",
-		level: "info",
-		msg: `${command.file} ${command.args.join(" ")}`,
-		event: "js_swap"
-	});
-	const spawn = spawnFn || ((cmd, args, opts) => e.spawn(cmd, args, opts));
-	const transcript = [];
-	const push = (line) => {
-		const msg = cleanLine(line);
-		if (msg.trim() === "") return;
-		transcript.push(msg);
-		logWriter?.write?.({
-			src: "build",
-			level: "debug",
-			msg,
-			raw: true,
-			event: "js_swap"
-		});
-	};
-	let child;
-	try {
-		child = spawn(command.file, command.args, {
-			cwd: root,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			env: {
-				...process.env,
-				FORCE_COLOR: "0"
-			}
-		});
-	} catch (err) {
-		return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(err)}`);
-	}
-	const reader = {
-		out: createLineReader(push),
-		err: createLineReader(push)
-	};
-	child.stdout?.setEncoding?.("utf-8");
-	child.stderr?.setEncoding?.("utf-8");
-	child.stdout?.on("data", (chunk) => reader.out.push(chunk));
-	child.stderr?.on("data", (chunk) => reader.err.push(chunk));
-	const stopHeartbeat = startBuildHeartbeat({
-		intervalMs: heartbeatMs,
-		elapsed,
-		emit: onHeartbeat,
-		label: "swap"
-	});
-	let outcome;
-	try {
-		outcome = await waitForChild(child);
-	} finally {
-		stopHeartbeat();
-	}
-	reader.out.flush();
-	reader.err.flush();
-	if (outcome.error) return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(outcome.error)}`);
-	if (outcome.code !== 0) {
-		const how = outcome.signal ? `signal ${outcome.signal}` : `exit code ${outcome.code}`;
-		return fail("bundle", `\`${command.args.slice(0, 2).join(" ")}\` failed (${how})`, tailLines(transcript, LAST_LINES));
-	}
-	if (!exists(bundleOutput)) return fail("bundle", `the bundle command exited 0 but wrote no ${JS_BUNDLE_NAME} at ${bundleOutput}`);
-	let hermes = false;
-	let note;
-	if (hermesEnabled ?? readHermesEnabled(root)) {
-		const hermesc = hermescPath(root);
-		if (!exists(hermesc)) note = `hermesc not found at ${hermesc}; embedding the plain JS bundle instead of Hermes bytecode`;
-		else {
-			const hbc = join(tmp, `${JS_BUNDLE_NAME}.hbc`);
-			try {
-				e.runFile(hermesc, hermescArgs({
-					bundle: bundleOutput,
-					out: hbc
-				}));
-				e.runFile("mv", [hbc, bundleOutput]);
-				hermes = true;
-			} catch (err) {
-				return fail("hermesc", `hermesc failed on ${bundleOutput}: ${describe(err)}`);
-			}
-		}
-	}
-	try {
-		e.runFile("cp", [bundleOutput, join(appCopy, JS_BUNDLE_NAME)]);
-		e.runFile("cp", [
-			"-R",
-			`${assetsDest}/.`,
-			`${appCopy}/`
-		]);
-	} catch (err) {
-		return fail("replace", `could not replace the JS bundle inside ${appCopy}: ${describe(err)}`);
-	}
-	if (catalogTarget && catalogDir) {
-		const catalogBundle = join(appCopy, ASSET_CATALOG_BUNDLE);
-		try {
-			rmSync(catalogBundle, {
-				recursive: true,
-				force: true
-			});
-			if (readdirSync(catalogDir).some((name) => name.endsWith(".imageset"))) {
-				mkdirSync(catalogBundle);
-				const output = e.runFile("xcrun", actoolArgs({
-					catalog: catalogDir,
-					out: catalogBundle,
-					target: catalogTarget
-				}));
-				if (!exists(join(catalogBundle, "Assets.car"))) return fail("actool", `actool wrote no Assets.car into ${catalogBundle}`, tailLines(output.split("\n"), LAST_LINES));
-				writeFileSync(join(catalogBundle, "Info.plist"), ASSET_CATALOG_BUNDLE_INFO_PLIST);
-			}
-		} catch (err) {
-			const stdout = String(err?.stdout ?? "");
-			return fail("actool", `could not compile the image asset catalog into ${catalogBundle}: ${describe(err)}`, tailLines(stdout.split("\n"), LAST_LINES));
-		}
-	}
-	if (exists(join(appCopy, IOS_FRAMEWORK_UPDATES_MANIFEST))) return fail("updates", `the expo-updates manifest sits inside a nested framework (${IOS_FRAMEWORK_UPDATES_MANIFEST}), where a swap cannot refresh it without re-signing that framework`);
-	for (const manifest of IOS_UPDATES_MANIFESTS.map((name) => join(appCopy, name)).filter(exists)) try {
-		refreshUpdatesManifestFile(manifest, now());
-	} catch (err) {
-		return fail("updates", `could not refresh the expo-updates manifest ${manifest}: ${describe(err)}`);
-	}
-	try {
-		e.runFile("codesign", [
-			"--force",
-			"--sign",
-			"-",
-			appCopy
-		]);
-	} catch (err) {
-		return fail("codesign", `codesign --force --sign - ${appCopy} failed: ${describe(err)}`);
-	}
-	logWriter?.write?.({
-		src: "build",
-		level: "info",
-		msg: `JS swap done: ${hermes ? "hermes bytecode" : "plain JS"} into ${appCopy} in ${elapsed()}ms`,
-		event: "js_swap"
-	});
-	const result = {
-		ok: true,
-		appPath: appCopy,
-		tmpDir: tmp,
-		hermes,
-		durationMs: elapsed()
-	};
-	if (note) result.note = note;
-	return result;
-}
-function describe(err) {
-	return String(err?.message || err);
-}
-//#endregion
-//#region src/cache/miss-reason.ts
-const MISS_CHANGE_CAP = 20;
-function recordedBuilds(state, platform) {
-	const builds = [];
-	for (const value of [state?.[LAST_BUILD_KEYS[platform]], state?.lastBuild]) {
-		const record = value;
-		if (record?.platform !== platform) continue;
-		const startedAt = typeof record.startedAt === "string" ? record.startedAt : "";
-		if (typeof record.fingerprint === "string" && typeof record.cacheKey === "string") builds.push({
-			fingerprint: record.fingerprint,
-			cacheKey: record.cacheKey,
-			startedAt
-		});
-		const carried = record.missReason?.baseline;
-		if (typeof carried?.fingerprint === "string" && typeof carried.cacheKey === "string") builds.push({
-			fingerprint: carried.fingerprint,
-			cacheKey: carried.cacheKey,
-			startedAt
-		});
-	}
-	return builds;
-}
-function projectIdentity(root) {
-	let real;
-	try {
-		real = realpathSync.native(root);
-	} catch {
-		return null;
-	}
-	for (let dir = real;; dir = dirname(dir)) {
-		if (existsSync(join(dir, ".git"))) {
-			const common = gitCommonDirOnDisk(dir);
-			return common ? `${common}\n${relative(dir, real)}` : null;
-		}
-		if (dirname(dir) === dir) return null;
-	}
-}
-function findMissBaseline(root, platform, { readState = readWorkspaceState, projectRoots = () => Object.keys(loadConfig()?.projects ?? {}), identity = projectIdentity, sourcesOf = (p, key) => storedSources(p, key, sharedBuildCache()) } = {}) {
-	for (const build of recordedBuilds(readState(root), platform)) {
-		const sources = sourcesOf(platform, build.cacheKey);
-		if (sources) return {
-			fingerprint: build.fingerprint,
-			cacheKey: build.cacheKey,
-			sources,
-			from: "workspace"
-		};
-	}
-	const project = identity(root);
-	if (!project) return null;
-	const others = [];
-	for (const other of projectRoots()) {
-		if (other === root || identity(other) !== project) continue;
-		others.push(...recordedBuilds(readState(other), platform));
-	}
-	for (const build of others.toSorted((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0))) {
-		const sources = sourcesOf(platform, build.cacheKey);
-		if (sources) return {
-			fingerprint: build.fingerprint,
-			cacheKey: build.cacheKey,
-			sources,
-			from: "project"
-		};
-	}
-	return null;
-}
-const CATEGORY_RANK = {
-	"native-dependency": 0,
-	"app-config": 1,
-	"config-plugin": 2,
-	package: 3,
-	"native-dir": 4,
-	file: 5,
-	"app-asset": 6,
-	other: 7,
-	"package-scripts": 8,
-	autolinking: 9
-};
-function packageIn(path) {
-	return [...path.matchAll(/(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)/g)].at(-1)?.[1] ?? null;
-}
-function describeChange({ name, change, reasons }) {
-	const pkg = packageIn(name);
-	if (name === "expoConfig" || reasons.includes("expoConfig")) return {
-		category: "app-config",
-		label: "app config changed"
-	};
-	if (pkg && reasons.some((reason) => /^(expo|rncore)Autolinking(Ios|Android)?$/.test(reason))) return {
-		category: "native-dependency",
-		label: `native dependency ${change}: ${pkg}`
-	};
-	if (pkg && reasons.includes("expoConfigPlugins")) return {
-		category: "config-plugin",
-		label: `config plugin ${change}: ${pkg}`
-	};
-	if (/^(expoAutolinkingConfig|rncoreAutolinkingConfig)(:|$)/.test(name)) return {
-		category: "autolinking",
-		label: "autolinking config changed"
-	};
-	if (name.startsWith("package:")) return {
-		category: "package",
-		label: `${name.slice(8)} ${change}`
-	};
-	if (name === "packageJson:scripts") return {
-		category: "package-scripts",
-		label: "package.json scripts changed"
-	};
-	if (reasons.includes("expoConfigExternalFile")) return {
-		category: "app-asset",
-		label: `app asset ${change}: ${name}`
-	};
-	if (reasons.includes("bareNativeDir")) return {
-		category: "native-dir",
-		label: `${name}/ ${change}`
-	};
-	if (reasons.length || name.includes("/") || name.includes(".")) return {
-		category: "file",
-		label: `${name} ${change}`
-	};
-	return {
-		category: "other",
-		label: `${name} ${change}`
-	};
-}
-function rekeyPrefix(rekeyedBy) {
-	return rekeyedBy.length ? `${rekeyedBy.join(" and ")} changed native inputs; ` : "";
-}
-function missReasonFromChanges({ changes, baseline, rekeyedBy = [] }) {
-	const prefix = rekeyPrefix(rekeyedBy);
-	if (!baseline) return {
-		kind: "no-baseline",
-		summary: `${prefix}no earlier build of this project in the cache to compare with`,
-		changes: [],
-		changeCount: 0,
-		baseline: null,
-		rekeyedBy
-	};
-	if (!changes.length) return {
-		kind: "same-sources",
-		summary: `${prefix}native inputs match the last build; no cached app for this configuration or target`,
-		changes: [],
-		changeCount: 0,
-		baseline,
-		rekeyedBy
-	};
-	const described = changes.map((change, index) => ({
-		change,
-		index,
-		...describeChange(change)
-	})).toSorted((a, b) => CATEGORY_RANK[a.category] - CATEGORY_RANK[b.category] || a.index - b.index);
-	const dependencyMoved = described.some((entry) => entry.category === "native-dependency");
-	const labels = [...new Set(described.filter((entry) => !(dependencyMoved && entry.category === "autolinking")).map((entry) => entry.label))];
-	const more = labels.length > 1 ? ` (+${labels.length - 1} more)` : "";
-	return {
-		kind: "changed",
-		summary: `${prefix}${labels[0]}${more}`,
-		changes: described.slice(0, MISS_CHANGE_CAP).map(({ change, category }) => ({
-			source: change.name,
-			change: change.change,
-			category
-		})),
-		changeCount: changes.length,
-		baseline,
-		rekeyedBy
-	};
-}
-function explainBuildMiss({ root, platform, current, rekeyedBy = [], baselineDeps, differ = expoFingerprint.diffFingerprints }) {
-	const baseline = findMissBaseline(root, platform, baselineDeps);
-	const changes = baseline ? diffFingerprintSources({
-		previous: baseline.sources,
-		previousHash: baseline.fingerprint,
-		current,
-		differ
-	}) : [];
-	return {
-		reason: missReasonFromChanges({
-			changes,
-			baseline: baseline ? {
-				fingerprint: baseline.fingerprint,
-				cacheKey: baseline.cacheKey,
-				from: baseline.from
-			} : null,
-			rekeyedBy
-		}),
-		changedNames: changes.map((change) => change.name),
-		previousHash: baseline?.fingerprint ?? null
-	};
-}
-function predictBuildMiss({ root, platform, current, prebuild }) {
-	const { reason } = explainBuildMiss({
-		root,
-		platform,
-		current
-	});
-	const baseline = reason.baseline && {
-		fingerprint: reason.baseline.fingerprint,
-		from: reason.baseline.from
-	};
-	if (!prebuild || !baseline) return {
-		...reason,
-		baseline
-	};
-	const dir = platform === "ios" ? "ios/" : "android/";
-	return {
-		...reason,
-		kind: "prebuild-pending",
-		summary: `${reason.summary} (before prebuild ${prebuild}s ${dir})`,
-		baseline
-	};
-}
-function skippedMissReason(summary) {
-	return {
-		kind: "cache-skipped",
-		summary,
-		changes: [],
-		changeCount: 0,
-		baseline: null,
-		rekeyedBy: []
-	};
-}
-function fingerprintErrorMissReason(message) {
-	return {
-		kind: "fingerprint-error",
-		summary: `fingerprinting failed: ${message}`,
-		changes: [],
-		changeCount: 0,
-		baseline: null,
-		rekeyedBy: []
-	};
-}
-//#endregion
-export { devicePlacementLine as _, UPDATES_MANIFEST_NAME as a, swapJsBundle as c, ensureOwnedDevice as d, AvdBootError as f, automaticDevicePlacement as g, checkEasFallback as h, skippedMissReason as i, didSetUpDevice as l, warmMetro as m, fingerprintErrorMissReason as n, detectEntryFile as o, AvdRecoveryError as p, predictBuildMiss as r, refreshUpdatesManifestFile as s, explainBuildMiss as t, ensureBooted as u, probeHost as v };