stim 1.0.0 → 1.2.0

package/dist/xcode-DeKCribl.mjs

@@ -0,0 +1,1832 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { C as withConfigLock, E as inspectProcessIdentity, _ as releaseAndroidConsolePort, b as setDevice, g as loadConfig, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, w as captureProcessIdentity, y as saveConfig } from "./config-CMtIaTk9.mjs";
+import { r as register } from "./cache-manifest-Cu4_Znw9.mjs";
+import { E as workspaceId, S as sharedCompilationCache, w as workspaceDerivedData } from "./state-CZ-ER-8d.mjs";
+import { s as ownedDeviceLabel } from "./project-BBTVABUz.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { r as pidExists } from "./metro-COslRK_F.mjs";
+import { C as selectParked, S as readParked, _ as teardownParkedIosSim, b as dropParked, g as teardownParkedAvd, m as teardownOwnedAvd, x as parkedMaxSetting, y as adoptParked } from "./remote-cache-DDmJ1Roq.mjs";
+import { U as resolveOptimizations, l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-DwU1_U_q.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-8wHMEde0.mjs";
+import { E as readHostMemoryPressure, T as hostMemoryPressureAdvice, _ as renameIosSim, b as resolveIosCreation, c as iosRuntimeMatches, d as listIosDeviceTypes, g as parseRuntimeVersion, i as createOwnedIosSim, l as iosSimulatorFailureAdvice, m as ownedSimName, n as bootIosSim, u as listAllIosSims, v as resetIosKeychain, x as resolveOwnedIosSim, y as resetIosPrivacy } from "./ios-D1h1Di39.mjs";
+import { f as releaseClaim, h as tryAcquireClaim, i as claimRemoveCommand, l as markClaimChildPending, n as ClaimRefusedError, p as setClaimChild, u as processGroupAlive } from "./ownership-claim-7zRxxTfZ.mjs";
+import { A as pickDefaultSystemImage, D as ownedAvdName, E as ownedAvdMatchesConfiguration, L as waitForBoot, N as resolveOwnedAvdSerial, O as ownedAvdSystemImage, b as listAvds, c as avdPoolConfiguration, d as configureNewOwnedAvd, f as createOwnedAvd, o as assertOwnedAvdStopped, u as bootAndroidEmulator, v as getAvdNameForSerial, w as nextConsolePort, x as listInstalledSystemImages, y as listAdbDevices } from "./android-K63_0UfF.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BKfdys1q.mjs";
+import { t as cleanLine } from "./server-expo-C3ktAwUG.mjs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import chalk from "chalk";
+//#region src/engine/simslim.ts
+async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
+	if (!profile && !previouslyManaged) return {
+		managed: false,
+		profile: null
+	};
+	const action = profile ? "on" : "off";
+	const args = profile ? [
+		"on",
+		udid,
+		"--profile",
+		profile
+	] : ["off", udid];
+	const lines = [];
+	const onLine = (raw) => {
+		const line = stripAnsi(raw).trim();
+		if (!line) return;
+		lines.push(line);
+		if (lines.length > 20) lines.shift();
+		out(`SimSlim: ${line}`);
+	};
+	const stdout = createLineReader(onLine);
+	const stderr = createLineReader(onLine);
+	const root = join(getConfigDir(), "simslim-locks", `${encodeURIComponent(udid.toLowerCase())}.lock`);
+	const label = `SimSlim for ${udid}`;
+	const attempt = tryAcquireClaim({
+		root,
+		mode: "exclusive",
+		label
+	});
+	if (attempt.pending) releaseClaim(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new ClaimRefusedError({
+		root,
+		claimPath: attempt.held?.path ?? root,
+		label,
+		reason: "another SimSlim operation is still using this simulator"
+	});
+	let child;
+	let result;
+	let identity;
+	let cancellation;
+	const stopGroup = () => {
+		if (child?.pid !== void 0 && identity && inspectProcessIdentity(identity) === "same") try {
+			process.kill(-child.pid, "SIGKILL");
+		} catch {}
+	};
+	const cancel = (signal) => {
+		cancellation ??= signal;
+		stopGroup();
+	};
+	const onInterrupt = () => cancel("SIGINT");
+	const onTerminate = () => cancel("SIGTERM");
+	const groupAlive = () => child?.pid !== void 0 && processGroupAlive(child.pid);
+	const settled = () => result !== void 0 && !groupAlive();
+	const waitUntil = async (deadline, cancellable = false) => {
+		while (!settled() && Date.now() < deadline) {
+			if (cancellable && cancellation) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(50, deadline - Date.now())));
+		}
+		return settled();
+	};
+	process.on("SIGINT", onInterrupt);
+	process.on("SIGTERM", onTerminate);
+	process.on("exit", stopGroup);
+	try {
+		markClaimChildPending(claim);
+		try {
+			child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				detached: true
+			});
+		} catch (error) {
+			throw simslimLaunchError(error);
+		}
+		child.stdout?.on("data", (chunk) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk) => stderr.push(chunk));
+		waitForChild(child).then((value) => {
+			result = value;
+		});
+		if (child.pid !== void 0) {
+			const captured = captureProcessIdentity(child.pid);
+			if (captured.ok) {
+				identity = {
+					pid: child.pid,
+					processToken: captured.token
+				};
+				try {
+					setClaimChild(claim, identity);
+				} catch {}
+			}
+		}
+		const completed = await waitUntil(Date.now() + timeoutMs, true);
+		if (cancellation || !completed) {
+			stopGroup();
+			const stopped = await waitUntil(Date.now() + cleanupMs);
+			const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+			const recovery = stopped ? "Its process group has stopped. Retry stim ios to reconcile the retained simulator settings." : `Its process group could not be confirmed stopped. The claim remains at ${claim.path}. Inspect the SimSlim process group ${child.pid ?? "unknown"} before retrying. Only when nothing is using it, remove the claim: ${claimRemoveCommand(claim.path)}`;
+			const message = `SimSlim ${action} ${cancellation ? `interrupted by ${cancellation}` : `exceeded ${Math.round(timeoutMs / 1e3)}s`}. ${recovery}${detail}`;
+			if (cancellation) out(message);
+			throw Object.assign(new Error(message), { code: cancellation ? "EINTR" : "ETIMEDOUT" });
+		}
+	} finally {
+		if (!child || settled()) releaseClaim(claim);
+		else {
+			child.stdout?.destroy?.();
+			child.stderr?.destroy?.();
+			child.unref();
+		}
+		process.off("SIGINT", onInterrupt);
+		process.off("SIGTERM", onTerminate);
+		process.off("exit", stopGroup);
+		if (cancellation) process.exit(cancellation === "SIGINT" ? 130 : 143);
+	}
+	stdout.flush();
+	stderr.flush();
+	if (result?.error) throw simslimLaunchError(result.error);
+	if (result?.code !== 0) {
+		const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+		throw new Error(`SimSlim ${action} failed with exit code ${result?.code ?? "unknown"}.${detail}`);
+	}
+	return {
+		managed: Boolean(profile),
+		profile: profile ?? null
+	};
+}
+function simslimLaunchError(error) {
+	const cause = error;
+	if (cause?.code === "ENOENT") return new Error("SimSlim is configured but the `simslim` command is not installed. Run `brew install mobai-app/tap/simslim`.", { cause });
+	return new Error(`Could not start SimSlim: ${String(cause?.message || cause)}`, { cause });
+}
+function simslimIsOnPath() {
+	try {
+		return Boolean(getExecutor().runQuiet("command -v simslim", { timeoutMs: 5e3 }));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/engine/device.ts
+function startIosBoot(udid, configure) {
+	const done = (async () => {
+		await bootIosSim(udid);
+		await configure();
+	})();
+	done.catch(() => {});
+	return {
+		udid,
+		done
+	};
+}
+async function ensureOwnedDevice({ platform, project, projectPath, settingsRoot = projectPath, label = ownedDeviceLabel(projectPath), settings, flags = {}, note = () => {}, out = () => {}, logFile = null, alive = pidExists, configureAvd = configureNewOwnedAvd, teardownAvd = teardownOwnedAvd, reconcileIosSimulator = reconcileSimSlim }) {
+	const record = project?.platforms?.[platform] ?? null;
+	if (platform === "ios") return ensureOwnedIosDevice({
+		record,
+		projectPath,
+		settingsRoot,
+		label,
+		settings,
+		flags,
+		note,
+		out,
+		reconcileIosSimulator
+	});
+	return ensureOwnedAndroidDevice({
+		record,
+		projectPath,
+		settingsRoot,
+		label,
+		settings,
+		flags,
+		note,
+		out,
+		logFile,
+		alive,
+		configureAvd,
+		teardownAvd
+	});
+}
+async function ensureOwnedIosDevice({ record, projectPath, settingsRoot, label, settings, flags, note, out, reconcileIosSimulator }) {
+	const memoryAdvice = hostMemoryPressureAdvice(readHostMemoryPressure());
+	if (memoryAdvice) out(chalk.yellow(phaseLine("memory", memoryAdvice)));
+	const simslimProfile = iosSimSlimProfileSetting(settings, settingsRoot);
+	if (record?.deviceUdid) {
+		if (record.owned) {
+			const resolved = resolveOwnedIosSim(record.deviceUdid);
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned by name -- creating a fresh owned sim instead of booting it.`));
+			else if (resolved.missing) {} else {
+				const sim = resolved.sim;
+				const wantedType = flags.deviceType || settings?.ios?.deviceType;
+				const deviceTypes = listIosDeviceTypes();
+				const mismatch = deviceTypeMismatch(sim.deviceTypeIdentifier, wantedType, deviceTypes);
+				if (mismatch) throw new Error(`${mismatch}. Stim will not silently boot a different model. Run \`stim worktree remove\` (or \`stim gc --delete\`) to reap the current sim, then \`stim ios\` again to create the requested one.`);
+				const model = {
+					model: deviceTypes.find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null,
+					runtime: parseRuntimeVersion(sim.runtime)
+				};
+				const name = await withIosDeviceNameLock(() => renameToOwnedName(sim, label, model, projectPath));
+				const updated = {
+					deviceUdid: sim.udid,
+					owned: true,
+					deviceName: name,
+					...record.simslimManaged ? { simslimManaged: true } : {},
+					...record.adopted ? { adopted: true } : {},
+					...record.adoptionPending ? { adoptionPending: true } : {},
+					...record.parkedCacheKey ? { parkedCacheKey: record.parkedCacheKey } : {}
+				};
+				const configure = async () => {
+					if (record.adoptionPending) resetAdoptedSim(sim.udid, out);
+					return configureOwnedIosSim({
+						record: updated,
+						projectPath,
+						profile: simslimProfile,
+						out,
+						reconcileIosSimulator
+					});
+				};
+				const facts = {
+					deviceType: model.model,
+					runtime: model.runtime
+				};
+				if (sim.state !== "Booted") {
+					out(chalk.dim(phaseLine("device", `booting ${name} (${sim.udid})`)));
+					return {
+						...updated,
+						booting: startIosBoot(sim.udid, configure),
+						...facts
+					};
+				}
+				return {
+					...await configure(),
+					...facts
+				};
+			}
+		} else {
+			const sim = listAllIosSims().find((s) => s.udid === record.deviceUdid);
+			if (sim) {
+				if (sim.state !== "Booted") {
+					note(chalk.yellow(`Note: assigned sim ${sim.name} (${sim.udid}) 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 sim."));
+				}
+				return record;
+			}
+		}
+	}
+	const choice = resolveIosCreation({
+		deviceType: flags.deviceType || settings.ios?.deviceType,
+		runtime: flags.runtime || settings.ios?.runtime
+	});
+	const adopted = parkedMaxSetting("ios").max > 0 ? await withIosDeviceNameLock(() => takeParkedIosSim({
+		projectPath,
+		label,
+		choice,
+		out
+	})) : null;
+	if (adopted) {
+		out(chalk.dim(phaseLine("device", `booting ${adopted.deviceName} (${adopted.deviceUdid})`)));
+		const booting = startIosBoot(adopted.deviceUdid, async () => {
+			resetAdoptedSim(adopted.deviceUdid, out);
+			await configureOwnedIosSim({
+				record: adopted,
+				projectPath,
+				profile: simslimProfile,
+				out,
+				reconcileIosSimulator
+			});
+		});
+		return {
+			...adopted,
+			booting,
+			deviceType: choice.deviceType,
+			runtime: choice.runtime
+		};
+	}
+	const created = await withIosDeviceNameLock(() => {
+		const suffix = ownedIosNameSuffix(label, {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		}, projectPath);
+		const result = createOwnedIosSim(label, { suffix }, choice);
+		setDevice(projectPath, "ios", {
+			deviceUdid: result.udid,
+			owned: true,
+			deviceName: result.name
+		});
+		return result;
+	});
+	const newRecord = {
+		deviceUdid: created.udid,
+		owned: true,
+		deviceName: created.name
+	};
+	const booting = startIosBoot(created.udid, () => configureOwnedIosSim({
+		record: newRecord,
+		projectPath,
+		profile: simslimProfile,
+		out,
+		reconcileIosSimulator
+	}));
+	return {
+		...newRecord,
+		created: true,
+		booting,
+		deviceType: created.deviceType,
+		runtime: created.runtime
+	};
+}
+function withIosDeviceNameLock(fn) {
+	return withWorkspaceProcessLock(getConfigDir(), "ios-device-names", async () => fn(), { external: true });
+}
+function ownedIosNameSuffix(label, model, projectPath, udid) {
+	const names = new Set(listAllIosSims({ includeUnavailable: true }).filter((sim) => sim.udid !== udid).map((sim) => sim.name));
+	for (const project of Object.values(loadConfig()?.projects ?? {})) {
+		const record = project.platforms?.ios;
+		if (record?.deviceUdid !== udid && record?.deviceName) names.add(record.deviceName);
+	}
+	for (const parked of readParked("ios")) if (parked.udid !== udid) names.add(parked.name);
+	let suffix = "";
+	for (let attempt = 0; names.has(ownedSimName(label, model, suffix)); attempt++) suffix = ` ${workspaceId(projectPath)}${attempt ? `-${attempt}` : ""}`;
+	return suffix;
+}
+function renameToOwnedName(sim, label, model, projectPath) {
+	const wanted = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, sim.udid));
+	if (sim.name === wanted) return wanted;
+	try {
+		renameIosSim(sim.udid, wanted);
+		return wanted;
+	} catch {
+		return sim.name;
+	}
+}
+function resetAdoptedSim(udid, out) {
+	out(chalk.dim(phaseLine("device", `resetting privacy grants and the keychain on ${udid}`)));
+	resetIosPrivacy(udid);
+	resetIosKeychain(udid);
+}
+function takeParkedIosSim({ projectPath, label, choice, out }) {
+	const candidates = selectParked(readParked("ios"), {
+		deviceTypeIdentifier: choice.deviceTypeId,
+		runtimeIdentifier: choice.runtimeId
+	});
+	if (candidates.length === 0) return null;
+	const listed = new Map(listAllIosSims({ includeUnavailable: true }).map((sim) => [sim.udid, sim]));
+	for (const parked of candidates) {
+		const sim = listed.get(parked.udid);
+		if (!sim || !sim.available) {
+			const result = sim ? teardownParkedIosSim(parked.udid, { label: parked.name }) : null;
+			if (sim ? result?.status === "torn-down" : dropParked("ios", parked.udid)) out(chalk.dim(phaseLine("device", `deleted parked ${parked.name} (${parked.udid}): ${sim ? "unavailable" : "gone"}`)));
+			else if (result?.status === "failed") out(chalk.yellow(phaseLine("device", `could not delete unavailable parked ${parked.name} (${parked.udid}): ${result.reason}`)));
+			continue;
+		}
+		if (!sim.name.startsWith("stim-")) {
+			out(chalk.yellow(phaseLine("device", `kept parked record for ${parked.udid}: simulator is now named ${JSON.stringify(sim.name)} and is not Stim-owned`)));
+			continue;
+		}
+		const model = {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		};
+		const name = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, parked.udid));
+		const device = {
+			deviceUdid: parked.udid,
+			owned: true,
+			deviceName: name,
+			adopted: true,
+			adoptionPending: true,
+			...parked.simslimManaged ? { simslimManaged: true } : {},
+			...parked.cacheKey ? { parkedCacheKey: parked.cacheKey } : {}
+		};
+		if (!adoptParked({
+			platform: "ios",
+			projectPath,
+			udid: parked.udid,
+			device
+		})) continue;
+		try {
+			renameIosSim(parked.udid, name);
+		} catch {}
+		return device;
+	}
+	return null;
+}
+function clearIosAdoptionPending(projectPath) {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		const ios = cfg?.projects?.[projectPath]?.platforms?.ios;
+		if (!cfg || !ios?.adoptionPending) return;
+		delete ios.adopted;
+		delete ios.adoptionPending;
+		delete ios.parkedCacheKey;
+		saveConfig(cfg);
+	});
+}
+async function configureOwnedIosSim({ record, projectPath, profile, out, reconcileIosSimulator }) {
+	if (profile) out(chalk.dim(phaseLine("device", `applying the SimSlim profile to ${record.deviceUdid}`)));
+	else if (record.simslimManaged) out(chalk.dim(phaseLine("device", `restoring stock simulator services on ${record.deviceUdid}`)));
+	const previouslyManaged = Boolean(record.simslimManaged);
+	if (profile && !record.simslimManaged) {
+		const pending = {
+			...record,
+			simslimManaged: true
+		};
+		setDevice(projectPath, "ios", pending);
+		record = pending;
+	}
+	const result = await reconcileIosSimulator({
+		udid: record.deviceUdid,
+		profile,
+		previouslyManaged,
+		out
+	});
+	const updated = { ...record };
+	if (result.managed) updated.simslimManaged = true;
+	else delete updated.simslimManaged;
+	setDevice(projectPath, "ios", updated);
+	return updated;
+}
+function findOtherProjectOwningAvd(avdName, projectPath) {
+	const cfg = loadConfig();
+	for (const [path, proj] of Object.entries(cfg?.projects || {})) {
+		if (path === projectPath) continue;
+		if (proj?.platforms?.android?.avdName === avdName) return path;
+	}
+	return null;
+}
+var AvdRecoveryError = class extends Error {
+	remedy;
+	constructor(message, remedy, cause) {
+		super(message, { cause });
+		this.remedy = remedy;
+	}
+};
+async function ensureOwnedAndroidDevice({ record, projectPath, settingsRoot, label, settings, flags, note, out, logFile, alive, configureAvd, teardownAvd }) {
+	const avdConfig = androidAvdConfigSetting(settings, settingsRoot);
+	const configuration = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), avdConfig);
+	if (record?.setupIncomplete && record.avdName) {
+		const cleanup = teardownAvd(record.avdName, {
+			del: true,
+			owner: { projectPath }
+		});
+		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new Error(`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.`);
+		clearDevice(projectPath, "android");
+		record = null;
+	}
+	if (record?.avdName) {
+		if (record.owned) {
+			const resolved = resolveOwnedAvdSerial(record.avdName);
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded AVD ${record.avdName} is not Stim-owned by name -- 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);
+				return {
+					...updated,
+					systemImage: ownedAvdSystemImage(record.avdName)
+				};
+			} 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({
+						avdName: record.avdName,
+						metadata: record,
+						projectPath,
+						deviceName: record.deviceName,
+						out,
+						logFile,
+						alive
+					}),
+					systemImage: ownedAvdSystemImage(record.avdName)
+				};
+			}
+		} 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).toSorted((a, b) => a.parkedAt.localeCompare(b.parkedAt));
+		for (const parked of candidates) {
+			if (parked.deletionClaim !== void 0) 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, 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: configuration,
+				adoptionPending: true
+			};
+			if (!adoptParked({
+				platform: "android",
+				projectPath,
+				udid: parked.udid,
+				device: adopted
+			})) continue;
+			return {
+				...await bootOwnedAvdOnFreshPort({
+					avdName: parked.name,
+					projectPath,
+					metadata: adopted,
+					out,
+					logFile,
+					alive
+				}),
+				adopted: true,
+				systemImage
+			};
+		}
+	}
+	let created;
+	let fresh = false;
+	try {
+		created = withConfigLock(() => {
+			const current = loadConfig()?.projects?.[projectPath]?.platforms?.android;
+			if (current?.avdName && current.avdName !== record?.avdName) throw new Error(`Another Stim run assigned AVD ${current.avdName} to this workspace. Retry to use it.`);
+			if (readParked("android").some((entry) => entry.name === ownedAvdName(label)) || findOtherProjectOwningAvd(ownedAvdName(label), projectPath)) label = `${label}-${randomUUID().slice(0, 8)}`;
+			const result = createOwnedAvd(label, { systemImage: flags.systemImage || settings.android?.systemImage });
+			setDevice(projectPath, "android", {
+				avdName: result.avdName,
+				owned: true,
+				deviceName: result.avdName,
+				setupIncomplete: true,
+				poolConfiguration: configuration
+			});
+			return result;
+		});
+		fresh = true;
+	} catch (e) {
+		const message = String(e?.message || e);
+		const avdName = ownedAvdName(label);
+		if (message.includes("already exists")) {
+			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.", e);
+				created = withConfigLock(() => {
+					if (readParked("android").some((entry) => entry.name === avdName)) throw new Error(`AVD ${avdName} was parked by another Stim run. Retry to adopt it safely.`, { cause: e });
+					const owner = findOtherProjectOwningAvd(avdName, projectPath);
+					if (owner) throw new Error(`AVD ${avdName} already exists and is owned by another project (${owner}). Retry to allocate a distinct owned emulator.`, { cause: e });
+					const current = loadConfig()?.projects?.[projectPath]?.platforms?.android;
+					if (current?.avdName) {
+						const state = current.setupIncomplete ? "has incomplete setup" : "was registered";
+						throw new Error(`AVD ${current.avdName} ${state} by another concurrent Stim run. Retry after that run finishes so the recorded device is resolved safely.`, { cause: e });
+					}
+					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: e });
+					if (!resolved.serial) assertOwnedAvdStopped(avdName);
+					const recovered = {
+						avdName,
+						owned: true,
+						deviceName: avdName,
+						...resolved.serial ? { consolePort: Number(resolved.serial.replace(/^emulator-/, "")) } : {}
+					};
+					setDevice(projectPath, "android", recovered);
+					return {
+						...recovered,
+						systemImage: ownedAvdSystemImage(avdName),
+						serial: resolved.serial
+					};
+				});
+			} catch (error) {
+				if (error instanceof AvdRecoveryError) throw error;
+				throw new AvdRecoveryError(`Could not recover owned AVD ${avdName}: ${String(error?.message || error)}`, "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.", error);
+			}
+			out(chalk.dim(phaseLine("device", `recovered ${avdName} (unrecorded from a prior run)`)));
+			if (created.serial) return {
+				...created,
+				owned: true,
+				deviceName: avdName,
+				created: false
+			};
+		} else throw e;
+	}
+	if (fresh) try {
+		configureAvd(created.avdName, {
+			dataPartitionSizeGb: androidDataPartitionSizeGbSetting(settings),
+			avdConfig
+		});
+	} catch (error) {
+		const cleanup = teardownAvd(created.avdName, {
+			del: true,
+			owner: { projectPath }
+		});
+		const kept = cleanup.status === "failed" || cleanup.status === "skipped";
+		if (!kept) clearDevice(projectPath, "android");
+		const orphan = kept ? ` 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 ${created.avdName}, but could not configure its AVD settings: ${String(error?.message || error)}${orphan}`, { cause: error });
+	}
+	return {
+		...await bootOwnedAvdOnFreshPort({
+			avdName: created.avdName,
+			metadata: fresh ? { poolConfiguration: configuration } : void 0,
+			projectPath,
+			deviceName: created.avdName,
+			out,
+			logFile,
+			alive
+		}),
+		created: fresh,
+		systemImage: created.systemImage
+	};
+}
+function claimAndroidConsolePort({ projectPath, avdName, deviceName, livePorts = [], metadata }, { lock = withConfigLock, recordedPorts = () => allConsolePortsAndSerials().androidConsolePorts, record = setDevice } = {}) {
+	return lock(() => {
+		const consolePort = nextConsolePort([...recordedPorts(), ...livePorts]);
+		const claim = {
+			...metadata?.poolConfiguration ? { poolConfiguration: metadata.poolConfiguration } : {},
+			...metadata?.adoptionPending ? { adoptionPending: true } : {},
+			avdName,
+			consolePort,
+			owned: true,
+			deviceName: deviceName ?? avdName
+		};
+		record(projectPath, "android", claim);
+		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, metadata, projectPath, deviceName, out, logFile = null, alive = pidExists }) {
+	const claim = claimAndroidConsolePort({
+		projectPath,
+		avdName,
+		deviceName,
+		livePorts: liveAndroidConsolePorts(),
+		metadata
+	});
+	const serial = `emulator-${claim.consolePort}`;
+	try {
+		const pid = bootAndroidEmulator(avdName, claim.consolePort, { logFile });
+		out(chalk.dim(phaseLine("device", `waiting for ${serial} to finish booting`)));
+		const result = await waitForBoot(serial, 12e4, { aborted: emulatorGone(pid, alive) });
+		if (!result.ok) throw new Error(`${bootFailurePrefix(serial, result.exited, 12e4)} Diagnostic: ${JSON.stringify(result.diagnostic)}`);
+		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.`);
+		return {
+			...claim,
+			serial
+		};
+	} catch (error) {
+		releaseAndroidConsolePort(projectPath, claim.consolePort);
+		throw error;
+	}
+}
+function emulatorGone(pid, alive) {
+	if (!pid) return () => false;
+	return () => !alive(pid);
+}
+function bootFailurePrefix(serial, exited, timeoutMs) {
+	return exited ? `The emulator process for ${serial} exited before the device finished booting.` : `Emulator ${serial} did not finish booting within ${Math.round(timeoutMs / 1e3)}s.`;
+}
+function liveOwnedDeviceCount({ sims = [], adbEmulators = [], config = null } = {}) {
+	let count = 0;
+	for (const sim of sims) if (sim?.state === "Booted" && sim.name?.startsWith("stim-")) count++;
+	const livePorts = new Set(adbEmulators.map((e) => e.consolePort));
+	for (const proj of Object.values(config?.projects || {})) {
+		const android = proj?.platforms?.android;
+		if (android?.owned && android.avdName && typeof android.consolePort === "number" && livePorts.has(android.consolePort)) count++;
+	}
+	return count;
+}
+function workspaceHasLiveDevice({ platform, project, sims = [], adbEmulators = [] } = {}) {
+	if (!platform) return false;
+	const record = project?.platforms?.[platform];
+	if (!record) return false;
+	if (platform === "ios") return sims.some((s) => s.udid === record.deviceUdid && s.state === "Booted");
+	return typeof record.consolePort === "number" && adbEmulators.some((e) => e.consolePort === record.consolePort);
+}
+function deviceCapacityRefusal({ platform, project, max, sims = [], adb = null, config = null } = {}) {
+	if (!max || max <= 0) return null;
+	const adbEmulators = adb?.emulators || [];
+	if (workspaceHasLiveDevice({
+		platform,
+		project,
+		sims,
+		adbEmulators
+	})) return null;
+	const count = liveOwnedDeviceCount({
+		sims,
+		adbEmulators,
+		config
+	});
+	if (count < max) return null;
+	return {
+		code: "STIM_AT_CAPACITY",
+		message: `${count} Stim device(s) are already booted and concurrency.maxDevices is ${max}, so booting another would exceed the cap.`,
+		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
+	};
+}
+function checkDeviceCapacity({ platform, project, max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
+	if (!max || max <= 0) return null;
+	let simList = [];
+	let adbRes = {
+		emulators: [],
+		physical: [],
+		unhealthy: []
+	};
+	try {
+		simList = typeof sims === "function" ? sims() || [] : sims || [];
+	} catch {}
+	try {
+		adbRes = typeof adb === "function" ? adb() || adbRes : adb || adbRes;
+	} catch {}
+	let cfg = null;
+	try {
+		cfg = typeof config === "function" ? config() : config ?? null;
+	} catch {}
+	return deviceCapacityRefusal({
+		platform,
+		project,
+		max,
+		sims: simList,
+		adb: adbRes,
+		config: cfg
+	});
+}
+function deviceTypeMismatch(recordedTypeId, requestedName, deviceTypes) {
+	if (!requestedName || !recordedTypeId) return null;
+	const wanted = (deviceTypes || []).find((d) => d.name === requestedName);
+	if (!wanted) return null;
+	if (wanted.identifier === recordedTypeId) return null;
+	const recorded = (deviceTypes || []).find((d) => d.identifier === recordedTypeId);
+	return `this project's sim is ${recorded ? recorded.name : recordedTypeId}, but --device-type asked for ${requestedName}`;
+}
+function installedNames(names) {
+	const unique = [...new Set(names.filter((n) => typeof n === "string" && n !== ""))];
+	return unique.length > 0 ? unique.join(", ") : "none";
+}
+function unknownIosRuntimeRefusal(requested, runtimes) {
+	if (!requested) return null;
+	if ((runtimes || []).some((r) => iosRuntimeMatches(r, requested))) return null;
+	return {
+		message: `No installed simulator runtime matches "${requested}". Installed runtimes: ${installedNames((runtimes || []).map((r) => r.version))}.`,
+		remedy: "Pass `--runtime` (or set ios.runtime) a version printed above (\"26.5\") or a runtime's full name (\"iOS 26.5\"); nothing else matches. Install more runtimes through Xcode."
+	};
+}
+function creatableIosDeviceTypeNames(runtimes, runtime) {
+	return (runtime ? (runtimes || []).filter((r) => iosRuntimeMatches(r, runtime)) : runtimes || []).flatMap((r) => (r.supportedDeviceTypes || []).map((d) => d.name));
+}
+function unknownIosDeviceTypeRefusal(requested, runtimes, runtime) {
+	if (!requested) return null;
+	const creatable = creatableIosDeviceTypeNames(runtimes, runtime);
+	if (creatable.includes(requested)) return null;
+	return {
+		message: `No device type named "${requested}" can be created on ${runtime ? `runtime ${runtime}` : "any installed simulator runtime"}. ${runtime ? `Device types runtime ${runtime} supports` : "Device types the installed runtimes support"}: ${installedNames(creatable)}.`,
+		remedy: "Pass `--device-type` (or set ios.deviceType) one of the names printed above, exactly as `xcrun simctl list devicetypes` spells it. `xcrun simctl list devicetypes` also lists watchOS, tvOS and visionOS models, which no iOS runtime can create. Install more models through Xcode."
+	};
+}
+function unknownAndroidSystemImageRefusal(requested, images) {
+	if (!requested) return null;
+	if ((images || []).some((i) => i.pkg === requested)) return null;
+	return {
+		message: `No installed Android system image is named "${requested}". Installed system images: ${installedNames((images || []).map((i) => i.pkg))}.`,
+		remedy: "Pass `--system-image` (or set android.systemImage) to one of the package ids printed above. Install more with `sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`."
+	};
+}
+const BOOT_POLL_MS = 500;
+async function ensureBooted({ platform, device, timeoutMs, pollMs = BOOT_POLL_MS, out = () => {}, logFile = null, alive = pidExists } = {}) {
+	if (platform === "ios") return ensureIosBooted({
+		device,
+		timeoutMs: timeoutMs ?? 6e5,
+		pollMs,
+		out
+	});
+	if (platform === "android") return ensureAndroidBooted({
+		device,
+		timeoutMs: timeoutMs ?? 24e4,
+		out,
+		logFile,
+		alive
+	});
+	return {
+		failed: true,
+		reason: `Unknown platform "${platform}".`
+	};
+}
+async function ensureIosBooted({ device, timeoutMs, pollMs, out }) {
+	const udid = device?.deviceUdid;
+	if (!udid) return {
+		failed: true,
+		reason: "No iOS simulator is recorded for this project."
+	};
+	const ready = () => {
+		try {
+			getExecutor().runFile("xcrun", [
+				"simctl",
+				"spawn",
+				udid,
+				"/usr/bin/true"
+			], { timeoutMs: 3e4 });
+			return {
+				ok: true,
+				udid
+			};
+		} catch (error) {
+			return {
+				failed: true,
+				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
+			};
+		}
+	};
+	const booting = device?.booting;
+	if (booting?.udid === udid) {
+		try {
+			await booting.done;
+		} catch (e) {
+			return {
+				failed: true,
+				reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+			};
+		}
+		return ready();
+	}
+	let resolved;
+	try {
+		resolved = resolveOwnedIosSim(udid);
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not list simulators: ${e?.message || e}`
+		};
+	}
+	if (resolved.missing) return {
+		failed: true,
+		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
+	};
+	if (resolved.notOwned) return {
+		failed: true,
+		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
+	};
+	const sim = resolved.sim;
+	if (sim.state === "Booted") return ready();
+	out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
+	const bootDeadline = Date.now() + timeoutMs;
+	try {
+		await bootIosSim(udid, { timeoutMs });
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not boot simulator ${udid}: ${e?.message || e}`
+		};
+	}
+	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
+	while (Date.now() < deadline) {
+		await sleep(pollMs);
+		let state = null;
+		try {
+			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
+		} catch {}
+		if (state === "Booted") return ready();
+	}
+	return {
+		failed: true,
+		reason: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
+	};
+}
+async function ensureAndroidBooted({ device, timeoutMs, out, logFile = null, alive = pidExists }) {
+	if (!device?.avdName) 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 by name; refusing to boot it.`
+	};
+	if (resolved.serial) {
+		const ready = await waitForBoot(resolved.serial, timeoutMs);
+		if (!ready.ok) return {
+			failed: true,
+			reason: `Emulator ${resolved.serial} never reported boot completion. Diagnostic: ${JSON.stringify(ready.diagnostic)}`
+		};
+		return {
+			ok: true,
+			serial: resolved.serial
+		};
+	}
+	const freshSerial = `emulator-${device.consolePort}`;
+	if (device.owned && device.serial === freshSerial) {
+		const ready = await waitForBoot(freshSerial, timeoutMs);
+		if (ready.ok) return {
+			ok: true,
+			serial: freshSerial
+		};
+		return {
+			failed: true,
+			reason: `Emulator ${freshSerial} never reported boot completion. Diagnostic: ${JSON.stringify(ready.diagnostic)}`
+		};
+	}
+	const serial = `emulator-${pickConsolePort(device.consolePort)}`;
+	out(chalk.dim(phaseLine("device", `booting ${device.avdName} as ${serial}`)));
+	let pid = null;
+	try {
+		pid = bootAndroidEmulator(device.avdName, Number(serial.replace(/^emulator-/, "")), { logFile });
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not start emulator for AVD ${device.avdName}: ${e?.message || e}`
+		};
+	}
+	const ready = await waitForBoot(serial, timeoutMs, { aborted: emulatorGone(pid, alive) });
+	if (!ready.ok) return {
+		failed: true,
+		reason: `${bootFailurePrefix(serial, ready.exited, timeoutMs)} Diagnostic: ${JSON.stringify(ready.diagnostic)}`
+	};
+	return {
+		ok: true,
+		serial
+	};
+}
+function pickConsolePort(recorded) {
+	const live = liveAndroidConsolePorts();
+	if (recorded && !live.includes(Number(recorded))) return Number(recorded);
+	return nextConsolePort([...allConsolePortsAndSerials().androidConsolePorts, ...live]);
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#endregion
+//#region src/engine/bundler.ts
+const COCOAPODS_SPEC = /^ {4}cocoapods \(/m;
+function bundlerPin(root) {
+	const gemfile = join(root, "Gemfile");
+	const lockfile = join(root, "Gemfile.lock");
+	if (!existsSync(gemfile)) return null;
+	let lock;
+	try {
+		lock = readFileSync(lockfile, "utf-8");
+	} catch {
+		return null;
+	}
+	if (!COCOAPODS_SPEC.test(lock)) return null;
+	return {
+		gemfile,
+		lockfile
+	};
+}
+function podInstallCommand(root, ...args) {
+	const pod = [
+		"pod",
+		"install",
+		...args
+	].join(" ");
+	return bundlerPin(root) ? `bundle exec ${pod}` : pod;
+}
+const BUILD_FAILED = "** BUILD FAILED **";
+const POSITIONED = /^(\S[^\t]*?):(\d+):(?:(\d+):)?\s*(?:fatal\s+)?error:\s+(.+)$/;
+const UNPOSITIONED = /^(\S[^\t]*?)?\berror:\s+(.+)$/;
+const LD_ERROR = /^ld:\s+(?!warning:)(.+)$/;
+const UNDEFINED_HEADER = /^(?:ld:\s+)?Undefined symbols?(?:\s+for architecture\s+\S+)?:\s*$/;
+const UNDEFINED_SYMBOL = /^\s+"?([^",]+)"?,\s+referenced from:\s*$/;
+function undefinedSymbolMessage(symbol) {
+	return `Undefined symbol: ${symbol}`;
+}
+const PODS_OUT_OF_SYNC = /The sandbox is not in sync with the Podfile\.lock/;
+const SIGNING = [
+	/No profiles for '.*' were found/,
+	/requires a development team/i,
+	/[Cc]ode ?[Ss]igning [Ee]rror/,
+	/No signing certificate/i,
+	/code signing is required/i,
+	/errSecInternalComponent/,
+	/Provisioning profile .* doesn't (?:include|match)/i
+];
+const NO_SUCH_SCHEME = /does not contain a scheme named/;
+const CAS_CORRUPT = /not a IncludeTreeRoot node kind/;
+const DEVICE_SIGNING_REMEDY = "Set a team and a Development profile for the target's configuration in Xcode > Signing & Capabilities, then build once from Xcode to install the profile. Stim never passes -allowProvisioningUpdates, because registering a device or minting a profile changes your Apple Developer account.";
+const SIMULATOR_SIGNING_REMEDY = "Stim builds for the simulator here, which needs no signing. Check CODE_SIGNING_REQUIRED / DEVELOPMENT_TEAM in the target's configuration, or build for a phone with `stim ios --device`.";
+function remedyFor(message, root, sdk) {
+	if (CAS_CORRUPT.test(message)) return "The compilation cache holds a damaged object. Run `stim gc --delete --cache \"compilation cache\"` to empty that cache, then build again. The next build is a cold one.";
+	if (PODS_OUT_OF_SYNC.test(message)) return `Run \`${root ? podInstallCommand(root) : "pod install"}\` in ios/ (stim ios does this when Podfile.lock and Pods/Manifest.lock disagree), then build again.`;
+	if (NO_SUCH_SCHEME.test(message)) return "Run `xcodebuild -list` in ios/ to see the schemes this project defines, and share the app scheme so it is visible to the build.";
+	for (const pattern of SIGNING) if (pattern.test(message)) return sdk.startsWith("iphoneos") ? DEVICE_SIGNING_REMEDY : SIMULATOR_SIGNING_REMEDY;
+	return null;
+}
+function fileFromPrefix(prefix) {
+	const trimmed = String(prefix).trim().replace(/:$/, "");
+	if (!trimmed) return null;
+	const head = (trimmed.split(": ")[0] ?? "").trim();
+	if (!head.includes("/")) return null;
+	return head;
+}
+function makeDiagnostic({ file = null, line = null, column = null, message }, root, sdk) {
+	const text = String(message).trim();
+	const out = { message: text };
+	if (file) out.file = file;
+	if (line !== null && line !== void 0) out.line = line;
+	if (column !== null && column !== void 0) out.column = column;
+	out.message = text;
+	const remedy = remedyFor(text, root, sdk);
+	if (remedy) out.remedy = remedy;
+	return out;
+}
+function dedupeKey(d) {
+	return `${d.file || ""}|${d.line || ""}|${d.column || ""}|${d.message}`;
+}
+function extractXcodeDiagnostics(transcript, root = null, sdk = "iphonesimulator") {
+	if (typeof transcript !== "string" || transcript === "") return [];
+	const lines = transcript.split("\n");
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (d) => {
+		const key = dedupeKey(d);
+		if (seen.has(key)) return;
+		seen.add(key);
+		out.push(d);
+	};
+	for (let i = 0; i < lines.length; i += 1) {
+		const rawLine = lines[i];
+		if (rawLine === void 0) continue;
+		const raw = rawLine.replace(/\r$/, "");
+		if (raw.includes(BUILD_FAILED)) break;
+		if (UNDEFINED_HEADER.test(raw)) {
+			for (let j = i + 1; j < lines.length; j += 1) {
+				const symLine = lines[j];
+				if (symLine === void 0) continue;
+				const sym = UNDEFINED_SYMBOL.exec(symLine.replace(/\r$/, ""));
+				if (sym) {
+					const symbol = sym[1];
+					if (symbol !== void 0) push(makeDiagnostic({ message: undefinedSymbolMessage(symbol) }, root, sdk));
+					continue;
+				}
+				if (/^\s+\S/.test(symLine) && !/^\S/.test(symLine)) continue;
+				i = j - 1;
+				break;
+			}
+			continue;
+		}
+		const ld = LD_ERROR.exec(raw);
+		if (ld) {
+			push(makeDiagnostic({ message: `ld: ${ld[1]}` }, root, sdk));
+			continue;
+		}
+		const positioned = POSITIONED.exec(raw);
+		if (positioned) {
+			const posMsg = positioned[4];
+			if (posMsg === void 0) continue;
+			push(makeDiagnostic({
+				file: positioned[1],
+				line: Number(positioned[2]),
+				column: positioned[3] === void 0 ? null : Number(positioned[3]),
+				message: posMsg
+			}, root, sdk));
+			continue;
+		}
+		const plain = UNPOSITIONED.exec(raw);
+		if (plain) {
+			const plainMsg = plain[2];
+			if (plainMsg === void 0) continue;
+			push(makeDiagnostic({
+				file: fileFromPrefix(plain[1] || ""),
+				message: plainMsg
+			}, root, sdk));
+		}
+	}
+	return out;
+}
+function capDiagnostics(diagnostics, max = 10) {
+	const list = Array.isArray(diagnostics) ? diagnostics : [];
+	if (list.length <= max) return {
+		diagnostics: list.slice(),
+		truncated: 0
+	};
+	return {
+		diagnostics: list.slice(0, max),
+		truncated: list.length - max
+	};
+}
+function describeDiagnostic(diagnostic) {
+	if (!diagnostic || typeof diagnostic !== "object") return "";
+	const { file, line, column, message } = diagnostic;
+	if (!file) return String(message ?? "");
+	return `${file}${line ? column ? `:${line}:${column}` : `:${line}` : ""}: ${message}`;
+}
+//#endregion
+//#region src/engine/xcode.ts
+const IOS_DIR = "ios";
+const PREBUILD_REMEDY = "Generate it with `npx expo prebuild -p ios` (stim ios does this automatically for an Expo project with no ios/ directory), or commit the native project.";
+function buildFailure(message, remedy) {
+	return { error: {
+		code: "STIM_BUILD_FAILED",
+		message,
+		remedy
+	} };
+}
+function pickXcodeProject(entries) {
+	const names = (Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string");
+	const workspaces = names.filter((e) => e.endsWith(".xcworkspace")).toSorted();
+	const projects = names.filter((e) => e.endsWith(".xcodeproj")).toSorted();
+	if (workspaces.length > 0) {
+		const projectNames = new Set(projects.map((p) => basename(p, ".xcodeproj")));
+		const file = workspaces.find((w) => projectNames.has(basename(w, ".xcworkspace"))) || workspaces[0];
+		if (file === void 0) return null;
+		return {
+			kind: "workspace",
+			flag: "-workspace",
+			file,
+			name: basename(file, ".xcworkspace")
+		};
+	}
+	if (projects.length > 0) {
+		const file = projects[0];
+		if (file === void 0) return null;
+		return {
+			kind: "project",
+			flag: "-project",
+			file,
+			name: basename(file, ".xcodeproj")
+		};
+	}
+	return null;
+}
+function discoverXcodeProject(root) {
+	const dir = join(root, IOS_DIR);
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return buildFailure(`No ${IOS_DIR}/ directory in ${root}.`, PREBUILD_REMEDY);
+	}
+	const picked = pickXcodeProject(entries);
+	if (!picked) return buildFailure(`${dir} contains no .xcworkspace and no .xcodeproj.`, PREBUILD_REMEDY);
+	return {
+		...picked,
+		dir,
+		path: join(dir, picked.file)
+	};
+}
+function parseSchemeList(text) {
+	const empty = {
+		name: null,
+		schemes: []
+	};
+	if (typeof text !== "string") return empty;
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start < 0 || end <= start) return empty;
+	let data;
+	try {
+		data = JSON.parse(text.slice(start, end + 1));
+	} catch {
+		return empty;
+	}
+	if (!data || typeof data !== "object") return empty;
+	const record = data;
+	const container = record.workspace || record.project;
+	if (!container || typeof container !== "object") return empty;
+	const info = container;
+	const schemes = Array.isArray(info.schemes) ? info.schemes.filter((s) => typeof s === "string" && s.trim() !== "") : [];
+	return {
+		name: typeof info.name === "string" ? info.name : null,
+		schemes
+	};
+}
+const TEST_SCHEME = /(?:UI)?Tests$/;
+function pickScheme(schemes, containerName) {
+	const list = (Array.isArray(schemes) ? schemes : []).filter((s) => typeof s === "string" && s.trim() !== "");
+	if (list.length === 0) return null;
+	const name = typeof containerName === "string" ? containerName.trim() : "";
+	if (name) {
+		const exact = list.find((s) => s === name);
+		if (exact) return exact;
+		const insensitive = list.find((s) => s.toLowerCase() === name.toLowerCase());
+		if (insensitive) return insensitive;
+	}
+	const app = list.filter((s) => !TEST_SCHEME.test(s));
+	return app.length === 1 ? app[0] : null;
+}
+const LIST_TIMEOUT_MS = 18e4;
+function listSchemes(project, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		return parseSchemeList(executor.runFile("xcodebuild", [
+			project.flag,
+			project.path,
+			"-list",
+			"-json"
+		], { timeoutMs: LIST_TIMEOUT_MS }));
+	} catch {
+		return null;
+	}
+}
+function resolveScheme(project, { exec = null, scheme: requested = null } = {}) {
+	const listing = listSchemes(project, { exec });
+	if (listing === null) return { error: {
+		code: "STIM_NO_SCHEME",
+		message: `Could not list schemes for ${project.path}.`,
+		remedy: `Run \`xcodebuild ${project.flag} ${project.path} -list\` to see what it reports.`
+	} };
+	if (requested !== null) {
+		if (listing.schemes.includes(requested)) return {
+			scheme: requested,
+			schemes: listing.schemes
+		};
+		return { error: {
+			code: "STIM_NO_SCHEME",
+			message: `No shared Xcode scheme named ${JSON.stringify(requested)} in ${project.path}. Available schemes: ${listing.schemes.join(", ") || "none"}.`,
+			remedy: "Pass an exact available name with --scheme, or share the intended app scheme in Xcode."
+		} };
+	}
+	let scheme = pickScheme(listing.schemes, listing.name || project.name);
+	if (!scheme && project.dir) try {
+		const app = JSON.parse(readFileSync(join(project.dir, "..", "app.json"), "utf8"));
+		scheme = pickScheme(listing.schemes, app?.name);
+	} catch {}
+	if (!scheme) {
+		const found = listing.schemes.length ? listing.schemes.join(", ") : "none";
+		return { error: {
+			code: "STIM_NO_SCHEME",
+			message: `Could not select an app scheme in ${project.path} (schemes: ${found}).`,
+			remedy: listing.schemes.length > 0 ? "Pass --scheme <name> to select the intended shared app scheme. Stim does not guess between unmatched schemes." : "Share the app scheme in Xcode (Product > Scheme > Manage Schemes, tick Shared) so xcodebuild can see it."
+		} };
+	}
+	return {
+		scheme,
+		schemes: listing.schemes
+	};
+}
+const PREFIX_MAP_TARGET = "/^src";
+function prefixMapping(workspaceRoot) {
+	return `${String(workspaceRoot).replace(/\/+$/, "")}=${PREFIX_MAP_TARGET}`;
+}
+function compilationPrefixMappings(workspaceRoot, derivedDataPath) {
+	const source = resolve(workspaceRoot);
+	const derived = resolve(derivedDataPath);
+	const mappings = [prefixMapping(source)];
+	const rel = relative(source, derived);
+	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) mappings.push(`${derived}=/^derived-data`);
+	return mappings.join(" ");
+}
+function ccacheEnabled(podfileProperties) {
+	if (!podfileProperties || typeof podfileProperties !== "object") return false;
+	return podfileProperties["apple.ccacheEnabled"] === "true";
+}
+function readPodfileProperties(root) {
+	try {
+		const parsed = JSON.parse(readFileSync(join(root, IOS_DIR, "Podfile.properties.json"), "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function compilationCacheSettings({ workspaceRoot, derivedDataPath, casPath, xcodeMajor, ccache = false, optimizations = resolveOptimizations({}, {}).ios }) {
+	if (xcodeMajor === null || xcodeMajor === void 0) return [];
+	if (xcodeMajor < 26) return [];
+	if (ccache) return [];
+	return [
+		`COMPILATION_CACHE_ENABLE_CACHING=${optimizations.compilationCache ? "YES" : "NO"}`,
+		`COMPILATION_CACHE_CAS_PATH=${casPath}`,
+		`SWIFT_ENABLE_COMPILE_CACHE=${optimizations.compilationCache && optimizations.swiftCompilationCache ? "YES" : "NO"}`,
+		`CLANG_ENABLE_PREFIX_MAPPING=${optimizations.prefixMapping ? "YES" : "NO"}`,
+		`CLANG_OTHER_PREFIX_MAPPINGS=${optimizations.prefixMapping ? compilationPrefixMappings(workspaceRoot, derivedDataPath) : ""}`
+	];
+}
+function parseXcodeMajor(output) {
+	const m = /^Xcode\s+(\d+)/m.exec(String(output || ""));
+	if (!m) return null;
+	const digits = m[1];
+	if (digits === void 0) return null;
+	const major = parseInt(digits, 10);
+	return Number.isFinite(major) ? major : null;
+}
+function detectXcodeMajor(exec = null) {
+	return parseXcodeMajor((exec || getExecutor()).runQuiet("xcodebuild -version", { timeoutMs: 1e4 }));
+}
+function resolveCompilationCacheSettings({ root, derivedDataPath, exec = null, casPath = sharedCompilationCache(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
+	const settings = compilationCacheSettings({
+		workspaceRoot: root,
+		derivedDataPath,
+		casPath,
+		xcodeMajor: detectXcodeMajor(exec),
+		ccache: ccacheEnabled(readPodfileProperties(root)),
+		optimizations
+	});
+	if (settings.length > 0 && optimizations.compilationCache) {
+		register({
+			dir: casPath,
+			name: "Xcode compilation cache",
+			prune: "atomic",
+			note: "shared Xcode compilation cache"
+		});
+		onNote(chalk.dim(phaseLine("cache", `compilation cache on (CAS at ${casPath})`)));
+	}
+	return settings;
+}
+function xcodebuildArgs({ project, scheme, udid = null, destination = null, configuration = "Debug", sdk = "iphonesimulator", derivedDataPath, extraArgs = [], buildSettings = [] }) {
+	return [
+		project.flag,
+		project.path,
+		"-scheme",
+		scheme,
+		"-configuration",
+		configuration,
+		"-sdk",
+		sdk,
+		"-destination",
+		destination || `id=${udid}`,
+		"-derivedDataPath",
+		derivedDataPath,
+		...extraArgs,
+		"build",
+		...buildSettings
+	];
+}
+function productsDir(derivedDataPath, { configuration = "Debug", sdk = "iphonesimulator" } = {}) {
+	return join(derivedDataPath, "Build", "Products", `${configuration}-${sdk}`);
+}
+function pickAppBundle(entries, preferredName = null) {
+	const apps = (Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string" && e.endsWith(".app")).toSorted();
+	if (apps.length === 0) return null;
+	if (preferredName) {
+		const wanted = `${preferredName}.app`;
+		const exact = apps.find((a) => a === wanted);
+		if (exact) return exact;
+	}
+	return apps[0];
+}
+function findAppBundle(dir, preferredName = null) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return null;
+	}
+	const app = pickAppBundle(entries, preferredName);
+	return app ? join(dir, app) : null;
+}
+function parseBundleId(plistJson) {
+	if (typeof plistJson !== "string") return null;
+	let data;
+	try {
+		data = JSON.parse(plistJson);
+	} catch {
+		return null;
+	}
+	if (!data || typeof data !== "object") return null;
+	const id = data.CFBundleIdentifier;
+	return typeof id === "string" && id.trim() !== "" ? id.trim() : null;
+}
+function readBundleId(appPath, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		const id = parseBundleId(executor.runFile("plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			join(appPath, "Info.plist")
+		]));
+		if (id) return id;
+	} catch {}
+	try {
+		const value = executor.runFile("defaults", [
+			"read",
+			join(appPath, "Info"),
+			"CFBundleIdentifier"
+		]);
+		const trimmed = String(value).trim();
+		return trimmed === "" ? null : trimmed;
+	} catch {
+		return null;
+	}
+}
+function parseBundleExecutable(plistJson) {
+	if (typeof plistJson !== "string") return null;
+	let data;
+	try {
+		data = JSON.parse(plistJson);
+	} catch {
+		return null;
+	}
+	if (!data || typeof data !== "object") return null;
+	const name = data.CFBundleExecutable;
+	return typeof name === "string" && name.trim() !== "" ? name.trim() : null;
+}
+function readBundleExecutable(appPath, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		const name = parseBundleExecutable(executor.runFile("plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			join(appPath, "Info.plist")
+		]));
+		if (name) return name;
+	} catch {}
+	try {
+		const value = executor.runFile("defaults", [
+			"read",
+			join(appPath, "Info"),
+			"CFBundleExecutable"
+		]);
+		const trimmed = String(value).trim();
+		return trimmed === "" ? null : trimmed;
+	} catch {
+		return null;
+	}
+}
+function tailLines(lines, count = 5) {
+	return (Array.isArray(lines) ? lines : []).filter((l) => typeof l === "string" && l.trim() !== "").slice(-count);
+}
+const HEARTBEAT_INTERVAL_MS = 3e4;
+const HEARTBEAT_ACTIVITY = {
+	build: "compiling",
+	deps: "installing",
+	pods: "installing"
+};
+function heartbeatLine(elapsedMs, label = "build", estimateMs = null) {
+	const activity = HEARTBEAT_ACTIVITY[label] ?? "running";
+	const elapsed = formatElapsed(elapsedMs);
+	const inside = estimateMs && estimateMs > 0 ? elapsedMs > estimateMs ? `${elapsed}, usually ~${formatElapsed(estimateMs)}` : `${elapsed} of ~${formatElapsed(estimateMs)}` : elapsed;
+	return phaseLine(label, `still ${activity} (${inside})`);
+}
+const defaultSchedule = (run, delayMs) => {
+	const timer = setTimeout(run, delayMs);
+	timer.unref?.();
+	return () => clearTimeout(timer);
+};
+function startBuildHeartbeat({ intervalMs, elapsed, emit, label = "build", estimateMs = null, schedule = defaultSchedule }) {
+	if (!(intervalMs > 0)) return () => {};
+	let stopped = false;
+	let lastBeat = 0;
+	let cancel = null;
+	function tick() {
+		if (stopped) return;
+		const ms = elapsed();
+		const beat = Math.floor(ms / intervalMs) * intervalMs;
+		if (beat > lastBeat) {
+			lastBeat = beat;
+			emit(heartbeatLine(beat, label, estimateMs));
+		}
+		cancel = schedule(tick, intervalMs - ms % intervalMs);
+	}
+	cancel = schedule(tick, intervalMs);
+	return () => {
+		stopped = true;
+		cancel?.();
+	};
+}
+function failedResult({ code, diagnostics, durationMs, exitCode = null, transcriptLines = 0, tail = [], compilationCache = COMPILATION_CACHE_UNAVAILABLE }) {
+	const capped = capDiagnostics(diagnostics);
+	return {
+		failed: true,
+		code,
+		diagnostics: capped.diagnostics,
+		truncated: capped.truncated,
+		durationMs,
+		exitCode,
+		transcriptLines,
+		tail,
+		compilationCache
+	};
+}
+const COMPILATION_CACHE_UNAVAILABLE = {
+	status: "unavailable",
+	hits: null,
+	cacheableTasks: null,
+	hitRatePercent: null
+};
+const COMPILATION_CACHE_NOT_RUN = {
+	status: "not-run",
+	hits: null,
+	cacheableTasks: null,
+	hitRatePercent: null
+};
+function parseCompilationCacheActivity(line) {
+	if (typeof line !== "string") return null;
+	const match = line.match(/(?:note:\s*)?(\d+) hits \/ (\d+) cacheable tasks \((\d+(?:\.\d+)?)%\)/);
+	if (!match) return null;
+	return {
+		status: "reported",
+		hits: Number(match[1]),
+		cacheableTasks: Number(match[2]),
+		hitRatePercent: Number(match[3])
+	};
+}
+function compilationCacheActivityLine(activity) {
+	if (activity.status === "reported") return `${activity.hits}/${activity.cacheableTasks} hits (${activity.hitRatePercent}%)`;
+	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
+	return "unavailable; Xcode did not report reliable statistics";
+}
+async function buildIos({ root, udid = null, logWriter, project = null, scheme = null, configuration = "Debug", sdk = "iphonesimulator", destination = null, derivedDataPath = null, extraArgs = [], compilationCache = void 0, optimizations = resolveOptimizations({}, {}).ios, now = () => Date.now(), exec = null, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), onNote = (line) => console.error(line) }) {
+	if (!root || typeof root !== "string") throw new TypeError("buildIos requires {root}");
+	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildIos requires {logWriter} with a write() method");
+	if (!udid && !destination) throw new TypeError("buildIos requires {udid} (or an explicit {destination})");
+	const executor = exec || getExecutor();
+	const dd = derivedDataPath || (scheme ? join(workspaceDerivedData(root), `scheme-${createHash("sha256").update(scheme).digest("hex")}`) : workspaceDerivedData(root));
+	const startedAt = now();
+	const elapsed = () => now() - startedAt;
+	const reportError = (message, remedy) => {
+		logWriter.write({
+			src: "build",
+			level: "error",
+			msg: message,
+			event: "build_diagnostic",
+			...remedy ? { remedy } : {}
+		});
+	};
+	let target = project;
+	if (!target) {
+		const discovered = discoverXcodeProject(root);
+		if (discovered.error) {
+			reportError(discovered.error.message, discovered.error.remedy);
+			return failedResult({
+				code: discovered.error.code,
+				diagnostics: [{
+					message: discovered.error.message,
+					remedy: discovered.error.remedy ?? void 0
+				}],
+				durationMs: elapsed()
+			});
+		}
+		target = discovered;
+	}
+	const resolvedTarget = target;
+	const selected = resolveScheme(resolvedTarget, {
+		exec: executor,
+		scheme
+	});
+	if (selected.error) {
+		reportError(selected.error.message, selected.error.remedy);
+		return failedResult({
+			code: selected.error.code,
+			diagnostics: [{
+				message: selected.error.message,
+				remedy: selected.error.remedy
+			}],
+			durationMs: elapsed()
+		});
+	}
+	const buildScheme = selected.scheme;
+	const buildSettings = compilationCache === void 0 ? resolveCompilationCacheSettings({
+		root,
+		derivedDataPath: dd,
+		exec: executor,
+		onNote,
+		optimizations
+	}) : compilationCache || [];
+	const args = xcodebuildArgs({
+		project: resolvedTarget,
+		scheme: buildScheme,
+		udid,
+		destination,
+		configuration,
+		sdk,
+		derivedDataPath: dd,
+		extraArgs,
+		buildSettings
+	});
+	logWriter.write({
+		src: "build",
+		level: "info",
+		msg: `xcodebuild ${args.join(" ")}`,
+		event: "build_start"
+	});
+	const transcript = [];
+	let compilationCacheActivity = COMPILATION_CACHE_UNAVAILABLE;
+	const onLine = (line) => {
+		const msg = cleanLine(line);
+		transcript.push(msg);
+		if (msg.trim() === "") return;
+		logWriter.write({
+			src: "build",
+			level: "debug",
+			msg
+		});
+		const activity = parseCompilationCacheActivity(msg);
+		if (activity) {
+			compilationCacheActivity = activity;
+			logWriter.write({
+				src: "build",
+				level: "info",
+				msg: compilationCacheActivityLine(activity),
+				event: "compilation_cache",
+				hits: activity.hits,
+				cacheableTasks: activity.cacheableTasks,
+				hitRatePercent: activity.hitRatePercent
+			});
+		}
+	};
+	let child;
+	try {
+		child = executor.spawn("xcodebuild", args, {
+			cwd: resolvedTarget.dir || root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: false,
+			env: {
+				...process.env,
+				NSUnbufferedIO: "YES",
+				FORCE_COLOR: "0"
+			}
+		});
+	} catch (err) {
+		const message = `Could not run xcodebuild: ${err.message}`;
+		const remedy = "Install Xcode and select it with `sudo xcode-select -s /Applications/Xcode.app`.";
+		reportError(message, remedy);
+		return failedResult({
+			code: "STIM_BUILD_FAILED",
+			diagnostics: [{
+				message,
+				remedy
+			}],
+			durationMs: elapsed()
+		});
+	}
+	const outReader = createLineReader(onLine);
+	const errReader = createLineReader(onLine);
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => outReader.push(chunk));
+	child.stderr?.on("data", (chunk) => errReader.push(chunk));
+	const stopHeartbeat = startBuildHeartbeat({
+		intervalMs: heartbeatMs,
+		elapsed,
+		emit: onHeartbeat,
+		estimateMs
+	});
+	const outcome = await new Promise((settlePromise) => {
+		let settled = false;
+		const finish = (value) => {
+			if (settled) return;
+			settled = true;
+			outReader.flush();
+			errReader.flush();
+			settlePromise(value);
+		};
+		child.on("close", (code, signal) => finish({
+			code,
+			signal
+		}));
+		child.on("error", (error) => finish({
+			code: null,
+			signal: null,
+			error
+		}));
+	});
+	stopHeartbeat();
+	const durationMs = elapsed();
+	const text = transcript.join("\n");
+	if (outcome.error) {
+		const message = `Could not run xcodebuild: ${outcome.error.message}`;
+		const remedy = "Install Xcode and select it with `sudo xcode-select -s /Applications/Xcode.app`.";
+		reportError(message, remedy);
+		return failedResult({
+			code: "STIM_BUILD_FAILED",
+			diagnostics: [{
+				message,
+				remedy
+			}],
+			durationMs,
+			transcriptLines: transcript.length,
+			tail: tailLines(transcript),
+			compilationCache: compilationCacheActivity
+		});
+	}
+	if (outcome.code !== 0) {
+		const diagnostics = extractXcodeDiagnostics(text, root, sdk);
+		const capped = capDiagnostics(diagnostics);
+		for (const d of capped.diagnostics) reportError(describeDiagnostic(d), d.remedy);
+		if (capped.diagnostics.length === 0) reportError(`xcodebuild exited ${outcome.code ?? `on ${outcome.signal}`} with no recognizable diagnostic; see the transcript above.`, null);
+		return failedResult({
+			code: "STIM_BUILD_FAILED",
+			diagnostics,
+			durationMs,
+			exitCode: outcome.code,
+			transcriptLines: transcript.length,
+			tail: tailLines(transcript),
+			compilationCache: compilationCacheActivity
+		});
+	}
+	const products = productsDir(dd, {
+		configuration,
+		sdk
+	});
+	let appPath = null;
+	if (scheme) try {
+		const targets = JSON.parse(executor.runFile("xcodebuild", [
+			resolvedTarget.flag,
+			resolvedTarget.path,
+			"-scheme",
+			buildScheme,
+			"-configuration",
+			configuration,
+			"-sdk",
+			sdk,
+			"-destination",
+			destination || `id=${udid}`,
+			"-derivedDataPath",
+			dd,
+			...extraArgs,
+			...buildSettings,
+			"-showBuildSettings",
+			"-json"
+		], { timeoutMs: 3e4 }));
+		const paths = /* @__PURE__ */ new Set();
+		for (const item of Array.isArray(targets) ? targets : []) {
+			const settings = item?.buildSettings;
+			if (settings?.PRODUCT_TYPE !== "com.apple.product-type.application" || settings.PLATFORM_NAME !== sdk) continue;
+			const dir = settings.TARGET_BUILD_DIR;
+			const name = settings.FULL_PRODUCT_NAME;
+			if (typeof dir !== "string" || !isAbsolute(dir) || typeof name !== "string" || basename(name) !== name || !name.endsWith(".app")) continue;
+			const path = join(dir, name);
+			if (statSync(path).isDirectory()) paths.add(path);
+		}
+		if (paths.size === 1) appPath = [...paths][0];
+	} catch {}
+	else appPath = findAppBundle(products, buildScheme);
+	if (!appPath) {
+		const message = scheme ? `xcodebuild succeeded, but the built app for scheme ${JSON.stringify(buildScheme)} could not be identified unambiguously from its build settings.` : `xcodebuild reported success but no .app is in ${products}.`;
+		const remedy = "Check that the scheme builds one application target for this platform, not a library, test bundle, or several apps.";
+		reportError(message, remedy);
+		return failedResult({
+			code: "STIM_BUILD_FAILED",
+			diagnostics: [{
+				message,
+				remedy
+			}],
+			durationMs,
+			exitCode: 0,
+			transcriptLines: transcript.length,
+			tail: tailLines(transcript),
+			compilationCache: compilationCacheActivity
+		});
+	}
+	const bundleId = readBundleId(appPath, { exec: executor });
+	if (!bundleId) {
+		const message = `No readable CFBundleIdentifier in ${join(appPath, "Info.plist")}.`;
+		const remedy = "Check PRODUCT_BUNDLE_IDENTIFIER in the target's Debug configuration.";
+		reportError(message, remedy);
+		return failedResult({
+			code: "STIM_BUILD_FAILED",
+			diagnostics: [{
+				message,
+				remedy
+			}],
+			durationMs,
+			exitCode: 0,
+			transcriptLines: transcript.length,
+			tail: tailLines(transcript),
+			compilationCache: compilationCacheActivity
+		});
+	}
+	logWriter.write({
+		src: "build",
+		level: "info",
+		msg: `BUILD SUCCEEDED ${appPath} (${bundleId}) in ${durationMs}ms`,
+		event: "build_done"
+	});
+	return {
+		appPath,
+		bundleId,
+		durationMs,
+		scheme: buildScheme,
+		project: resolvedTarget,
+		derivedDataPath: dd,
+		productsDir: products,
+		transcriptLines: transcript.length,
+		compilationCache: compilationCacheActivity
+	};
+}
+//#endregion
+export { unknownAndroidSystemImageRefusal as C, simslimIsOnPath as E, liveOwnedDeviceCount as S, unknownIosRuntimeRefusal as T, AvdRecoveryError as _, ccacheEnabled as a, ensureBooted as b, discoverXcodeProject as c, resolveScheme as d, startBuildHeartbeat as f, podInstallCommand as g, bundlerPin as h, buildIos as i, readBundleExecutable as l, describeDiagnostic as m, COMPILATION_CACHE_UNAVAILABLE as n, compilationCacheActivityLine as o, tailLines as p, HEARTBEAT_INTERVAL_MS as r, detectXcodeMajor as s, COMPILATION_CACHE_NOT_RUN as t, readBundleId as u, checkDeviceCapacity as v, unknownIosDeviceTypeRefusal as w, ensureOwnedDevice as x, clearIosAdoptionPending as y };