stim 1.18.0 → 1.20.0

package/dist/plan-placement-CtxkCO54.mjs

@@ -1,1859 +0,0 @@
-import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-CBtzyIgF.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-CgYMahz7.mjs";
-import { D as makeTemporaryDirectory, O as removeTemporaryEntry, c as gitCommonDirOnDisk } from "./worktree-CsKYexJM.mjs";
-import { u as ownedDeviceLabel } from "./project-C3ChRLZy.mjs";
-import { o as pidExists } from "./metro-Dh8T4Ytd.mjs";
-import { d as sharedBuildCache } from "./workspace-state-C59dqG-Z.mjs";
-import { B as readStats$1, M as estimateBuild, s as peekBudget } from "./budget-DIhL2BKx.mjs";
-import { E as teardownOwnedAvd, k as teardownParkedAvd } from "./workspaces-xXItD8Dj.mjs";
-import { C as diffFingerprintSources, I as storedSources, w as entryDir, y as artifactIn } from "./device-lease-Co-EwifR.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-DC3ZLuw0.mjs";
-import { M as readHostMemoryPressure, d as listAllIosSims } from "./ios-B3SbOWdw.mjs";
-import { a as androidAvdConfigSetting, c as androidDataPartitionSizeGbSetting } from "./settings-CQyMElEP.mjs";
-import { b as hostingMachines, g as resolveBuildMachine, m as namedBuildMachine } from "./client-DzhapoMB.mjs";
-import { t as clearDeviceIdleShutdown } from "./idle-shutdown-jjtxAn5C.mjs";
-import { i as countLiveOwnedDevices, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission, s as peekDeviceSlots } from "./device-capacity-EUOOYr8T.mjs";
-import { E as tailLines, T as startBuildHeartbeat, g as HEARTBEAT_INTERVAL_MS } from "./toolchain-Bnyd_K3A.mjs";
-import { t as cleanLine } from "./server-expo-DoBHhuzK.mjs";
-import { a as call, o as connectHost } from "./hosted-client-C-rMtppF.mjs";
-import { r as readHostedNative, s as writeHostedNative } from "./ios-state-B2pES6Vs.mjs";
-import { n as prepareHostedNative } from "./hosted-native-DeeOG8xZ.mjs";
-import { a as easAuthNote } from "./remote-cache-BGg7aGIZ.mjs";
-import { t as reconcileSimSlim } from "./simslim-EHBQ2R4G.mjs";
-import { i as ensureOwnedIosDevice, r as ensureIosBooted } from "./device-ios-6MewKKnc.mjs";
-import { i as staleNativeDirRefusal } from "./prebuild-juCyreaR.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import { LAST_BUILD_KEYS, 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 { resolveTieredBuild } from "@stim-cli/cache";
-import { request } from "node:http";
-//#region src/device-host/placement.ts
-function local$1(code, reason, skipped = []) {
-	return {
-		kind: "local",
-		code,
-		reason,
-		skipped
-	};
-}
-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 } = inputs;
-	const { count, max, queued } = here.devices;
-	const cannotTake = !(max === 0 || count !== null && count < max) || queued > 0;
-	const usage = max > 0 ? `${count} of ${max} devices in use` : `${count} devices in use, no device cap`;
-	const localReason = 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}`);
-	if (!offers.length) return local$1("no-remote-mac", "no remote Macs configured; " + localReason);
-	if (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 local$1("no-host-admits", `${localReason}; no host admits${cannotTake && !noWait ? "; waiting locally if needed" : ""}`, skipped);
-	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
-	};
-}
-async function automaticDevicePlacement({ root, slot, platform, selectors, buildMachine, noWait }, { 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 entries = machines();
-	if (entries === null) throw Object.assign(/* @__PURE__ */ new Error("remote.machines is invalid. Run stim guide settings and correct it."), { code: "STIM_HOSTING_REFUSED" });
-	const preference = resolveBuildMachine(buildMachine, process.env.STIM_REMOTE_BUILD, loadConfig$1()?.remote?.build);
-	buildMachine = namedBuildMachine(preference) ? preference : void 0;
-	const load = capacity();
-	const here = {
-		loadPerCore: load.loadPerCore,
-		maxLoadPerCore: load.maxLoadPerCore,
-		memoryPressure: memory(),
-		devices,
-		budgetRefusal: await budget(root)
-	};
-	const early = decideDevicePlacement({
-		platform,
-		here,
-		offers: entries.map((machine) => ({
-			machine,
-			failure: "not probed"
-		})),
-		buildMachine,
-		noWait
-	});
-	if (early.kind === "local" && early.skipped.length === 0) return local(early.code, early.reason);
-	const probes = await Promise.all(entries.map((machine) => probe(machine, platform, selectors)));
-	const decision = decideDevicePlacement({
-		platform,
-		here,
-		offers: probes.map((each) => each.probe),
-		buildMachine,
-		noWait
-	});
-	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/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
-//#region src/commands/build-plan.ts
-const DISCARD = {
-	file: "",
-	written: 0,
-	dropped: 0,
-	lastError: null,
-	write: () => true,
-	close: () => ({
-		file: "",
-		written: 0,
-		dropped: 0,
-		lastError: null
-	})
-};
-async function providerHit({ root, platform, cacheKey, providerConfig }, deps) {
-	if (!providerConfig) return null;
-	let destinationDir;
-	try {
-		destinationDir = makeTemporaryDirectory(root, "stim-plan-");
-	} catch (error) {
-		deps.note(chalk.yellow(phaseLine("cache", `provider not checked: ${error?.message || error}`)));
-		return null;
-	}
-	try {
-		const found = await resolveTieredBuild({
-			local: {
-				resolve: () => null,
-				store: () => null
-			},
-			loadProvider: () => deps.loadCacheProvider({
-				projectRoot: root,
-				config: providerConfig
-			}),
-			target: {
-				projectRoot: root,
-				platform,
-				key: cacheKey
-			},
-			destinationDir,
-			warn: (_code, message) => deps.note(chalk.yellow(phaseLine("cache", message)))
-		});
-		return found ? found.providerName ?? "the cache provider" : null;
-	} finally {
-		removeTemporaryEntry(destinationDir);
-	}
-}
-async function expoRemoteHit(lookup, deps) {
-	if (!lookup.expoRemote) return null;
-	const { root, platform, isExpo, fingerprint } = lookup;
-	const loaded = await deps.loadProjectProvider(root, { isExpo });
-	if (loaded?.unavailable) {
-		deps.note(chalk.yellow(phaseLine("cache", `provider not usable: ${loaded.unavailable}`)));
-		return null;
-	}
-	if (!loaded?.provider) return null;
-	const name = loaded.name ?? "the build cache provider";
-	if (name === "eas") {
-		const auth = deps.checkEasAuth({
-			projectRoot: root,
-			owner: loaded.owner || null
-		});
-		const authNote = easAuthNote(auth);
-		if (authNote) deps.note(chalk.yellow(phaseLine("cache", authNote)));
-		if (auth?.code === "logged-out") return null;
-	}
-	const hit = await deps.resolveRemote({
-		provider: loaded.provider,
-		platform,
-		projectRoot: root,
-		fingerprintHash: fingerprint,
-		runOptions: lookup.expoRemote.runOptions,
-		logWriter: DISCARD
-	});
-	if (hit?.timedOut) deps.note(chalk.yellow(phaseLine("cache", `${name} did not answer; counted as a miss`)));
-	else if (hit?.failed) deps.note(chalk.yellow(phaseLine("cache", `${name} could not be used: ${hit.failed}`)));
-	return hit?.appPath ? name : null;
-}
-async function planCachedBuild(lookup, deps) {
-	const { root, platform, isExpo, fingerprint, sources, cacheKey, cachePolicy } = lookup;
-	let cacheHit = false;
-	let provider = null;
-	if (cachePolicy.read) {
-		if (artifactIn(entryDir(platform, cacheKey))) cacheHit = "local";
-		else {
-			provider = (cachePolicy.remote ? await providerHit(lookup, deps) : null) ?? await expoRemoteHit(lookup, deps);
-			if (provider) cacheHit = "remote";
-		}
-	}
-	let prebuild = null;
-	let refusal = null;
-	let missReason;
-	if (!cacheHit) {
-		prebuild = deps.planPrebuild(root, platform, {
-			isExpo,
-			fingerprint,
-			sources
-		});
-		if (prebuild === "refuse") refusal = staleNativeDirRefusal(platform);
-		else if (cachePolicy.read) missReason = predictBuildMiss({
-			root,
-			platform,
-			current: {
-				hash: fingerprint,
-				sources
-			},
-			prebuild: prebuild === "generate" || prebuild === "regenerate" ? prebuild : null
-		});
-	}
-	return planPayload(lookup, {
-		fingerprint,
-		cacheKey,
-		cacheHit,
-		provider,
-		cacheSkipped: !cachePolicy.read,
-		prebuild,
-		...missReason ? { missReason } : {},
-		refusal
-	});
-}
-function planPayload({ platform, slot, projectKey }, found) {
-	const { refusal, missReason, ...rest } = found;
-	const outcome = refusal ? null : found.cacheHit ? "hit" : "cold";
-	const estimate = outcome ? estimateBuild(readStats$1().record?.history?.[projectKey], platform, outcome) : {
-		expectedMs: null,
-		basis: 0
-	};
-	return {
-		platform,
-		...slot === "default" ? {} : { slot },
-		...rest,
-		outcome,
-		expectedMs: estimate.expectedMs,
-		basis: estimate.basis,
-		...missReason ? { missReason } : {},
-		...refusal ? { refusal } : {}
-	};
-}
-function cacheLine(plan) {
-	if (plan.refusal) return `the build would refuse with ${plan.refusal.code}`;
-	if (plan.cacheHit === "local") return "local cache hit";
-	if (plan.cacheHit === "remote") return `remote cache hit (${plan.provider})`;
-	return `${plan.cacheSkipped ? "cache reads are off" : "cache miss"}: compiles${plan.prebuild === "generate" || plan.prebuild === "regenerate" ? `, ${plan.prebuild}s the native dir` : ""}`;
-}
-function printPlan(plan, json) {
-	if (json) {
-		console.log(JSON.stringify(plan));
-		return;
-	}
-	const slot = plan.slot ? ` [${plan.slot}]` : "";
-	console.log(phaseLine("plan", `${plan.platform}${slot} ${shortHash(plan.fingerprint)} -> ${cacheLine(plan)}`));
-	if (plan.placement) console.log(phaseLine("placement", plan.placement));
-	if (plan.missReason) console.log(phaseLine("cache", `miss: ${plan.missReason.summary}`));
-	if (plan.refusal) {
-		console.log(phaseLine("error", plan.refusal.message));
-		console.log(phaseLine("remedy", plan.refusal.remedy));
-		return;
-	}
-	console.log(phaseLine("expect", plan.expectedMs === null ? `unknown: no ${plan.outcome} run of this project is recorded yet` : `~${formatDuration(plan.expectedMs)} (median of ${plural(plan.basis, `${plan.outcome} run`)})`));
-}
-function refusePlan({ code, message, remedy }, json, lines = []) {
-	console.error(chalk.red(phaseLine("error", message)));
-	for (const line of lines) console.error(chalk.dim(phaseLine("", line)));
-	console.error(chalk.dim(phaseLine("remedy", remedy)));
-	console.error(chalk.red(phaseLine("failed", code)));
-	if (json) console.log(JSON.stringify({
-		code,
-		message,
-		remedy
-	}));
-	process.exitCode = 1;
-}
-const PLAN_ONLY_REMEDY = "Drop the flag to plan the owned simulator or emulator build, or run the command without --plan.";
-function planFlagRefusal(flag) {
-	return {
-		code: "STIM_BAD_ARG",
-		message: `${flag} does not apply to --plan, which predicts the next local build without choosing a device.`,
-		remedy: PLAN_ONLY_REMEDY
-	};
-}
-//#endregion
-//#region src/device-host/plan-placement.ts
-/**
-* Where `--plan` assumes the next run puts its simulator or emulator, with no session, reservation or state write.
-* A named Mac, or the Mac a recorded session already holds, answers with the device its `device-host.offer` would
-* give; `auto` repeats the placement decision a run makes now and, when that stays on this Mac, notes any Mac
-* whose device would key differently. The result predicts the cache key only; a run reads its own device.
-*/
-async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, deps = {} }) {
-	const { automatic = automaticDevicePlacement, probe = probeHost, machines = hostingMachines } = deps;
-	const named = async (name) => {
-		const result = await probe(name, platform, selectors);
-		if ("failure" in result.probe) return {
-			kind: "unknown",
-			reason: `${name} did not give a ${platform} device (${result.probe.failure})`
-		};
-		const { choice, declined } = result.probe.offer;
-		if (!choice) return {
-			kind: "unknown",
-			reason: `${name} has no ${platform} device for this selection${declined ? ` (${declined})` : ""}`
-		};
-		return {
-			kind: "hosted",
-			choice,
-			placement: `on ${name}`
-		};
-	};
-	if (machine !== "auto") return named(machine);
-	try {
-		const recorded = readHostedNative(root, platform, slot)[slot];
-		if (recorded) return await named(recorded.machine);
-		const placed = await automatic({
-			root,
-			slot,
-			platform,
-			selectors,
-			noWait: false
-		}, {
-			read: () => ({}),
-			write: () => {}
-		});
-		if (placed.target) return {
-			kind: "hosted",
-			choice: placed.target.choice,
-			placement: `on ${placed.target.host.machine}, as auto would now`
-		};
-		const names = machines() ?? [];
-		const differs = (await Promise.all(names.map((name) => probe(name, platform, selectors)))).flatMap(({ probe: each }) => "offer" in each && each.offer.choice && sameKey(each.offer.choice) === false ? [each.machine] : []);
-		if (differs.length) return {
-			kind: "local",
-			placement: `this Mac; auto may use ${differs.join(", ")}, which builds for another architecture, so its key differs`
-		};
-		return {
-			kind: "local",
-			placement: names.length ? `this Mac; auto may use ${names.join(", ")}` : "this Mac"
-		};
-	} catch (error) {
-		return {
-			kind: "unknown",
-			reason: error.message
-		};
-	}
-}
-//#endregion
-export { AvdBootError as _, printPlan as a, automaticDevicePlacement as b, fingerprintErrorMissReason as c, detectEntryFile as d, refreshUpdatesManifestFile as f, ensureOwnedDevice as g, ensureBooted as h, planPayload as i, skippedMissReason as l, didSetUpDevice as m, planCachedBuild as n, refusePlan as o, swapJsBundle as p, planFlagRefusal as r, explainBuildMiss as s, planHostedDevice as t, UPDATES_MANIFEST_NAME as u, AvdRecoveryError as v, devicePlacementLine as x, warmMetro as y };