stim 1.25.0 → 1.27.0

package/dist/toolchain-CbCG6C5Z.mjs

@@ -0,0 +1,2413 @@
+import { D as ownership_claim_exports, _ as spawnDeclared, b as operationState, g as signalDeclaredSpawns, h as refuseDeclaredSpawns, m as declareSpawnsOn, p as allowDeclaredSpawns, t as getExecutor, u as withWorkspaceProcessLock, v as stopDeclaringSpawnsOn, y as isTermination } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, T as workspaceDerivedData, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-BjqdjnJR.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-Dj-WT4BP.mjs";
+import { a as killOnAbort } from "./operation-exec-Dp4FuIGR.mjs";
+import { o as androidHome } from "./android-DriNoAVy.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { p as resolveOptimizations } from "./errors-DHm_U5gv.mjs";
+import { t as cleanLine } from "./server-expo-ABQs2XFA.mjs";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { ambientContext, ambientEnv } from "@stim-cli/core";
+import { stimBuildDigest } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/cache/cache-claim.ts
+const LABEL = "cache";
+const POLL_MS = 500;
+const EMPTYING_WAIT_MS = 6e5;
+/**
+* The claim set guarding a cache Stim can only empty whole. It sits beside the cache's resolved directory, so emptying
+* the cache never removes it and every path that reaches the same cache names the same set; before the cache exists,
+* its resolved parent stands in for it.
+*/
+function cacheClaimRoot(dir) {
+	return `${existsSync(dir) ? canonicalPath(dir) : join(canonicalPath(dirname(dir)), basename(dir))}.claims`;
+}
+function describe(holder) {
+	const { platform, projectRoot } = holder.details;
+	const where = typeof projectRoot === "string" ? ` in ${projectRoot}` : "";
+	return holder.mode === "shared" ? `the ${typeof platform === "string" ? platform : "iOS"} build (pid ${holder.owner.pid}${where}) may be using it` : `pid ${holder.owner.pid} is emptying it`;
+}
+/** Why the cache at `dir` may be in use, from its claim set, without taking or removing any claim. */
+function cacheUser(dir) {
+	const root = cacheClaimRoot(dir);
+	const survey = (0, ownership_claim_exports.readClaimSet)(root);
+	const problem = survey.unresolved[0];
+	if (problem) return `the cache claim ${problem.path} is unresolved, so a build may be using it`;
+	const holder = survey.live[0];
+	return holder ? describe(holder) : void 0;
+}
+/**
+* Takes the exclusive claim an emptier holds while it removes the cache's contents; a string is why it cannot.
+* It never waits for a build that holds the cache.
+*/
+function claimForEmptying(dir) {
+	try {
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: cacheClaimRoot(dir),
+			mode: "exclusive",
+			label: LABEL
+		});
+		if (attempt.acquired) return attempt.acquired;
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		return holder ? describe(holder) : `its claim at ${cacheClaimRoot(dir)} could not be taken`;
+	} catch (error) {
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return error.message;
+		return `its claim at ${cacheClaimRoot(dir)} could not be taken: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+/**
+* Takes the shared claim a build holds on the compilation cache it compiles with, waiting while an emptier holds it.
+* A claim set Stim cannot resolve, or no process identity, is a failure: the build never runs unguarded.
+*/
+async function shareCompilationCache({ dir, projectRoot, note, signal }) {
+	const started = Date.now();
+	let told = false;
+	for (;;) {
+		signal?.throwIfAborted();
+		let attempt;
+		let root = `${dir}.claims`;
+		try {
+			mkdirSync(dirname(dir), { recursive: true });
+			root = cacheClaimRoot(dir);
+			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+				root,
+				mode: "shared",
+				label: LABEL,
+				details: {
+					platform: "ios",
+					projectRoot
+				}
+			});
+		} catch (error) {
+			return { failure: (0, ownership_claim_exports.claimFailure)(error, null) ?? {
+				code: ownership_claim_exports.CLAIM_UNAVAILABLE,
+				message: `Stim could not take the compilation cache claim at ${root}: ${error instanceof Error ? error.message : String(error)}.`,
+				remedy: `Restore write access to ${dirname(root)}, then retry the same Stim command.`
+			} };
+		}
+		if (attempt.acquired) return { claim: attempt.acquired };
+		const emptier = attempt.held ? `pid ${attempt.held.owner.pid}` : "another process";
+		const waited = Date.now() - started;
+		if (waited >= EMPTYING_WAIT_MS) return { failure: {
+			code: "STIM_BUILD_FAILED",
+			message: `${emptier} has been emptying the compilation cache at ${dir} for ${formatElapsed(waited)}.`,
+			remedy: "Run the same command again once it has finished."
+		} };
+		if (!told) note(phaseLine("build", `waiting for ${emptier} to finish emptying the compilation cache at ${dir}`));
+		told = true;
+		await setTimeout$1(POLL_MS);
+	}
+}
+//#endregion
+//#region src/engine/native-run.ts
+const NATIVE_RUN_LOCK = "native-run";
+const NATIVE_RUN_WAIT_MS = 18e5;
+const WAIT_HEARTBEAT_MS = 3e4;
+const CANCEL_REQUEST_KEY = "nativeRunCancel";
+const REQUEST_POLL_MS = 250;
+function nativeRunHolder(holder) {
+	const { command, platform, slot, interrupt } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default",
+		takesSignals: interrupt === "signal"
+	};
+}
+function describeNativeRunHolder(holder, now) {
+	const { command, slot } = nativeRunHolder(holder);
+	const started = Date.parse(holder.startedAt);
+	const facts = [`pid ${holder.owner.pid}`];
+	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
+	if (command === null) return `another Stim run (${facts.join(", ")})`;
+	if (command === "build") return `an artifact build (${facts.join(", ")})`;
+	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
+}
+/**
+* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
+* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
+*/
+function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
+	let claimId = null;
+	let lastAt = 0;
+	return (holder, firstLine) => {
+		const at = now();
+		if (holder.claimId !== claimId) {
+			claimId = holder.claimId;
+			lastAt = at;
+			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
+			return;
+		}
+		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
+		lastAt = at;
+		write(`still waiting for ${describe(holder, at)}`);
+	};
+}
+/**
+* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
+* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
+* stopped slot is the workspace's only device. A build for another slot that stays is left running and
+* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
+*/
+function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
+	if (holder.command === "macos" || holder.command === "build") {
+		if (stopSlot !== void 0) return { action: "proceed" };
+		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+	}
+	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
+	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
+	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+}
+const requestListeners = /* @__PURE__ */ new Map();
+/**
+* Ask the run holding `claimId` to cancel: the request is written to the workspace state, where the run's watch
+* finds it, and a run in this process is told at once.
+*/
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+	requestListeners.get(claimId)?.();
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState$1(root)?.[CANCEL_REQUEST_KEY];
+	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
+	return { pid: request.pid };
+}
+function clearNativeRunCancel(root, claimId) {
+	try {
+		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
+	} catch {}
+}
+/** The active native run of `context`'s operation aborts this signal when it is cancelled. */
+function runCancellationSignal(context) {
+	return operationState(context).runSignal;
+}
+/** Why `context`'s native run was cancelled, or null while it was not. */
+function runCancellation(context) {
+	return operationState(context).cancelled;
+}
+function cancelledFailure(context, platform, { code, message }) {
+	const cancelled = runCancellation(context);
+	if (cancelled === null || code === "STIM_CLAIM_UNAVAILABLE") return null;
+	return {
+		code: "STIM_CANCELLED",
+		message: `The ${platform} run was ${cancelled} before it finished.`,
+		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
+		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
+	};
+}
+function cancelOnAbort({ context, root, claim, write, controller }) {
+	const state = operationState(context);
+	const cancel = () => {
+		if (controller.signal.aborted) return;
+		const request = cancelRequestFor(root, claim.claimId);
+		const cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		state.cancelled = cancelled;
+		state.handled = true;
+		controller.abort();
+		refuseDeclaredSpawns(context, `the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns(context, "SIGINT");
+		if (signalled > 0 || request) state.draining = true;
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+	};
+	const onAbort = () => {
+		if (!isTermination(context.signal.reason)) cancel();
+	};
+	const onRequest = () => {
+		if (controller.signal.aborted || !cancelRequestFor(root, claim.claimId)) return;
+		cancel();
+		state.abortOperation?.("stop");
+	};
+	context.signal.addEventListener("abort", onAbort);
+	if (context.signal.aborted) onAbort();
+	requestListeners.set(claim.claimId, onRequest);
+	const watch = setInterval(onRequest, REQUEST_POLL_MS);
+	watch.unref();
+	return async () => {
+		clearInterval(watch);
+		requestListeners.delete(claim.claimId);
+		context.signal.removeEventListener("abort", onAbort);
+		allowDeclaredSpawns(context);
+		await withWorkspaceStateLockAsync(root, () => clearNativeRunCancel(root, claim.claimId)).catch(() => {});
+	};
+}
+/**
+* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
+* command, platform and slot, and a wait for another holder is reported on `write`. An abort of `context.signal`
+* forwards an interrupt to the running declared build tool and refuses any later one; a run `stim stop` cancelled
+* stops before its next build tool or install. A `SIGTERM` abort reason is left to the caller.
+*/
+function withNativeBuildRun(context, root, details, fn, { write }) {
+	const notice = nativeRunWaitNotice({ write });
+	const state = operationState(context);
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		state.cancelled = null;
+		const controller = new AbortController();
+		state.runSignal = controller.signal;
+		const dispose = cancelOnAbort({
+			context,
+			root,
+			claim,
+			write,
+			controller
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			await dispose();
+			state.runSignal = void 0;
+		}
+	}, {
+		external: true,
+		signal: context.signal,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawnsFor: context,
+		details: {
+			...details,
+			interrupt: state.takesSignals ? "signal" : "request"
+		},
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
+//#region src/engine/bundler.ts
+const COCOAPODS_SPEC = /^ {4}cocoapods \(([^)\s]+)/m;
+/**
+* The Bundler pin `pod install` in `directory` runs under: the nearest Gemfile from `directory` up to `root`, as
+* Bundler finds it, when its Gemfile.lock resolves cocoapods.
+*/
+function bundlerPin(root, directory = root) {
+	for (let dir = directory;; dir = dirname(dir)) {
+		const gemfile = join(dir, "Gemfile");
+		if (existsSync(gemfile)) return lockedCocoapods(gemfile, join(dir, "Gemfile.lock"));
+		const up = relative(root, dir);
+		if (!up || up.startsWith("..") || dirname(dir) === dir) return null;
+	}
+}
+function lockedCocoapods(gemfile, lockfile) {
+	let lock;
+	try {
+		lock = readFileSync(lockfile, "utf-8");
+	} catch {
+		return null;
+	}
+	const cocoapods = COCOAPODS_SPEC.exec(lock)?.[1];
+	return cocoapods ? {
+		gemfile,
+		lockfile,
+		cocoapods
+	} : null;
+}
+function podInstallCommand(root, directory, ...args) {
+	const pod = [
+		"pod",
+		"install",
+		...args
+	].join(" ");
+	return bundlerPin(root, directory) ? `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 COMPILATION_CACHE_CORRUPTION = /OnDiskCAS: corrupt internal reference|CAS operation failed|not a IncludeTreeRoot node kind/;
+const DEVICE_SIGNING_REMEDY = "Set a team for the target's configuration in Xcode > Signing & Capabilities, then run `stim device provision ios`, which lists the Apple Developer account changes and asks before making them (agents run it only with the user's go-ahead), or build once from Xcode to install the profile. Builds never pass -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, pods, 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 \`${pods ? podInstallCommand(pods.root, pods.directory) : "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 }, pods, 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, pods, sdk);
+	if (remedy) out.remedy = remedy;
+	return out;
+}
+function dedupeKey(d) {
+	return `${d.file || ""}|${d.line || ""}|${d.column || ""}|${d.message}`;
+}
+function createXcodeDiagnosticCollector(root = null, sdk = "iphonesimulator", podDirectory = root) {
+	const pods = root ? {
+		root,
+		directory: podDirectory ?? root
+	} : null;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	let finished = false;
+	let inUndefinedSymbols = false;
+	const add = (d) => {
+		const key = dedupeKey(d);
+		if (seen.has(key)) return;
+		seen.add(key);
+		out.push(d);
+	};
+	const push = (line) => {
+		if (finished) return;
+		const raw = line.replace(/\r$/, "");
+		if (inUndefinedSymbols) {
+			const sym = UNDEFINED_SYMBOL.exec(raw);
+			if (sym) {
+				const symbol = sym[1];
+				if (symbol !== void 0) add(makeDiagnostic({ message: undefinedSymbolMessage(symbol) }, pods, sdk));
+				return;
+			}
+			if (/^\s+\S/.test(line) && !/^\S/.test(line)) return;
+			inUndefinedSymbols = false;
+		}
+		if (raw.includes(BUILD_FAILED)) {
+			finished = true;
+			return;
+		}
+		if (UNDEFINED_HEADER.test(raw)) {
+			inUndefinedSymbols = true;
+			return;
+		}
+		const ld = LD_ERROR.exec(raw);
+		if (ld) {
+			add(makeDiagnostic({ message: `ld: ${ld[1]}` }, pods, sdk));
+			return;
+		}
+		const positioned = POSITIONED.exec(raw);
+		if (positioned) {
+			const posMsg = positioned[4];
+			if (posMsg === void 0) return;
+			add(makeDiagnostic({
+				file: positioned[1],
+				line: Number(positioned[2]),
+				column: positioned[3] === void 0 ? null : Number(positioned[3]),
+				message: posMsg
+			}, pods, sdk));
+			return;
+		}
+		const plain = UNPOSITIONED.exec(raw);
+		if (plain) {
+			const plainMsg = plain[2];
+			if (plainMsg === void 0) return;
+			add(makeDiagnostic({
+				file: fileFromPrefix(plain[1] || ""),
+				message: plainMsg
+			}, pods, sdk));
+		}
+	};
+	return {
+		push,
+		diagnostics: 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
+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 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;
+async function probe(executor, file, args, options) {
+	const context = ambientContext();
+	context?.signal.throwIfAborted();
+	try {
+		return await executor.runFileAsync(file, args, {
+			...options,
+			declareFor: context,
+			onSpawn: killOnAbort(context?.signal)
+		});
+	} finally {
+		context?.signal.throwIfAborted();
+	}
+}
+async function listSchemes(project, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		return parseSchemeList(await probe(executor, "xcodebuild", [
+			project.flag,
+			project.path,
+			"-list",
+			"-json"
+		], { timeoutMs: LIST_TIMEOUT_MS }));
+	} catch {
+		return null;
+	}
+}
+async function resolveScheme(project, { exec = null, scheme: requested = null } = {}) {
+	const listing = await 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 set it in ios.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.appRoot ?? 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>, or set ios.scheme, 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.map((mapping) => /[\s"\\]/.test(mapping) ? `"${mapping.replace(/["\\]/g, "\\$&")}"` : mapping).join(" ");
+}
+const SWIFT_PREFIX_MAPPING_MIN_SWIFT = {
+	major: 6,
+	minor: 4
+};
+function swiftPrefixMappingSupported(version) {
+	if (!version) return false;
+	const min = SWIFT_PREFIX_MAPPING_MIN_SWIFT;
+	return version.major > min.major || version.major === min.major && version.minor >= min.minor;
+}
+function compilationCacheSettings({ workspaceRoot, derivedDataPath, casPath, xcodeMajor, swiftVersion = null, swiftCacheCompatible = false, ccache = false, optimizations = resolveOptimizations({}, {}).ios }) {
+	if (xcodeMajor === null || xcodeMajor === void 0) return [];
+	if (xcodeMajor < 26) return [];
+	if (ccache) return [];
+	const swiftMappable = swiftPrefixMappingSupported(swiftVersion);
+	const auto = swiftMappable && swiftCacheCompatible;
+	const swift = optimizations.compilationCache && (optimizations.swiftCompilationCache ?? auto);
+	const mappings = optimizations.prefixMapping ? compilationPrefixMappings(workspaceRoot, derivedDataPath) : "";
+	return [
+		`COMPILATION_CACHE_ENABLE_CACHING=${optimizations.compilationCache ? "YES" : "NO"}`,
+		`COMPILATION_CACHE_CAS_PATH=${casPath}`,
+		`SWIFT_ENABLE_COMPILE_CACHE=${swift ? "YES" : "NO"}`,
+		`CLANG_ENABLE_PREFIX_MAPPING=${optimizations.prefixMapping ? "YES" : "NO"}`,
+		`CLANG_OTHER_PREFIX_MAPPINGS=${mappings}`,
+		...swift && swiftMappable && optimizations.prefixMapping ? ["SWIFT_ENABLE_PREFIX_MAPPING=YES", `SWIFT_OTHER_PREFIX_MAPPINGS=${mappings}`] : ["SWIFT_ENABLE_PREFIX_MAPPING=NO"]
+	];
+}
+function parseSwiftVersion(output) {
+	const m = /\bSwift version (\d+)\.(\d+)/.exec(String(output || ""));
+	if (!m || m[1] === void 0 || m[2] === void 0) return null;
+	const major = parseInt(m[1], 10);
+	const minor = parseInt(m[2], 10);
+	return Number.isFinite(major) && Number.isFinite(minor) ? {
+		major,
+		minor
+	} : null;
+}
+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;
+}
+async function detectXcodeMajorAsync(exec = null) {
+	return parseXcodeMajor(await (exec || getExecutor()).runFileQuietAsync("xcodebuild", ["-version"], { timeoutMs: 1e4 }));
+}
+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;
+}
+async function readBundleId(appPath, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		const id = parseBundleId(await probe(executor, "plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			join(appPath, "Info.plist")
+		], { timeoutMs: 1e4 }));
+		if (id) return id;
+	} catch {}
+	try {
+		const value = await probe(executor, "defaults", [
+			"read",
+			join(appPath, "Info"),
+			"CFBundleIdentifier"
+		], { timeoutMs: 1e4 });
+		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;
+}
+async function readBundleExecutable(appPath, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	try {
+		const name = parseBundleExecutable(await probe(executor, "plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			join(appPath, "Info.plist")
+		], { timeoutMs: 1e4 }));
+		if (name) return name;
+	} catch {}
+	try {
+		const value = await probe(executor, "defaults", [
+			"read",
+			join(appPath, "Info"),
+			"CFBundleExecutable"
+		], { timeoutMs: 1e4 });
+		const trimmed = String(value).trim();
+		return trimmed === "" ? null : trimmed;
+	} catch {
+		return null;
+	}
+}
+const TAIL_LINES = 5;
+function tailLines(lines, count = TAIL_LINES) {
+	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, compilationCacheCorruption = null }) {
+	const capped = capDiagnostics(diagnostics);
+	return {
+		ok: false,
+		code,
+		diagnostics: capped.diagnostics,
+		truncated: capped.truncated,
+		durationMs,
+		exitCode,
+		transcriptLines,
+		tail,
+		compilationCache,
+		...compilationCacheCorruption ? { compilationCacheCorruption } : {}
+	};
+}
+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])
+	};
+}
+const SWIFT_CACHING_NEEDS_EXPLICIT_MODULES = /warning: swift compiler caching requires explicit module build/;
+function compilationCacheActivityLine(activity) {
+	if (activity.status === "reported") {
+		const swift = activity.swiftTargetsWithoutExplicitModules ? `; Swift excluded: ${activity.swiftTargetsWithoutExplicitModules} targets build without explicit modules (SWIFT_ENABLE_EXPLICIT_MODULES=NO)` : "";
+		return `${activity.hits}/${activity.cacheableTasks} hits (${activity.hitRatePercent}%)${swift}`;
+	}
+	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
+	return "unavailable; Xcode did not report reliable statistics";
+}
+async function buildXcode({ context = ambientContext(), root, udid = null, logWriter, project, scheme = null, configuration = "Debug", applicationTarget, sdk = "iphonesimulator", destination = null, arch = null, derivedDataPath = null, extraArgs = [], compilationCache, startedAt: clockStart, now = () => Date.now(), exec = null, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line) }) {
+	if (!root || typeof root !== "string") throw new TypeError("buildXcode requires {root}");
+	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildXcode requires {logWriter} with a write() method");
+	if (!udid && !destination) throw new TypeError("buildXcode 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 = clockStart ?? now();
+	const elapsed = () => now() - startedAt;
+	const reportError = (message, remedy) => {
+		logWriter.write({
+			src: "build",
+			level: "error",
+			msg: message,
+			event: "build_diagnostic",
+			...remedy ? { remedy } : {}
+		});
+	};
+	if (project.error) {
+		reportError(project.error.message, project.error.remedy);
+		return failedResult({
+			code: project.error.code,
+			diagnostics: [{
+				message: project.error.message,
+				remedy: project.error.remedy ?? void 0
+			}],
+			durationMs: elapsed()
+		});
+	}
+	const resolvedTarget = project;
+	const selected = await 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 cacheSettings = typeof compilationCache === "function" ? await compilationCache({
+		derivedDataPath: dd,
+		exec: executor
+	}) : compilationCache || [];
+	const debugSettings = configuration === "Debug" && sdk === "iphonesimulator" ? ["DEBUG_INFORMATION_FORMAT=dwarf"] : [];
+	const buildSettings = [
+		...cacheSettings,
+		...debugSettings,
+		...arch ? [`ARCHS=${arch}`, "ONLY_ACTIVE_ARCH=YES"] : []
+	];
+	const casPathSetting = "COMPILATION_CACHE_CAS_PATH=";
+	const casDir = cacheSettings.includes("COMPILATION_CACHE_ENABLE_CACHING=YES") ? cacheSettings.find((setting) => setting.startsWith(casPathSetting))?.slice(27) ?? null : null;
+	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 diagnosticCollector = createXcodeDiagnosticCollector(root, sdk, resolvedTarget.dir || root);
+	const tail = [];
+	let transcriptLines = 0;
+	let compilationCacheActivity = COMPILATION_CACHE_UNAVAILABLE;
+	let swiftTargetsWithoutExplicitModules = 0;
+	let compilationCacheCorruption = null;
+	const onLine = (line) => {
+		const msg = cleanLine(line);
+		transcriptLines += 1;
+		diagnosticCollector.push(msg);
+		if (msg.trim() === "") return;
+		if (casDir && !compilationCacheCorruption && COMPILATION_CACHE_CORRUPTION.test(msg)) compilationCacheCorruption = {
+			dir: casDir,
+			line: msg.trim()
+		};
+		tail.push(msg);
+		if (tail.length > TAIL_LINES) tail.shift();
+		logWriter.write({
+			src: "build",
+			level: "debug",
+			msg
+		});
+		if (SWIFT_CACHING_NEEDS_EXPLICIT_MODULES.test(msg)) swiftTargetsWithoutExplicitModules += 1;
+		const parsed = parseCompilationCacheActivity(msg);
+		if (parsed) {
+			const activity = swiftTargetsWithoutExplicitModules ? {
+				...parsed,
+				swiftTargetsWithoutExplicitModules
+			} : parsed;
+			compilationCacheActivity = activity;
+			logWriter.write({
+				src: "build",
+				level: "info",
+				msg: compilationCacheActivityLine(activity),
+				event: "compilation_cache",
+				hits: activity.hits,
+				cacheableTasks: activity.cacheableTasks,
+				hitRatePercent: activity.hitRatePercent,
+				...swiftTargetsWithoutExplicitModules ? { swiftTargetsWithoutExplicitModules } : {}
+			});
+		}
+	};
+	let cacheClaim = null;
+	if (casDir) {
+		const shared = await shareCompilationCache({
+			dir: casDir,
+			projectRoot: root,
+			note: onHeartbeat,
+			signal: AbortSignal.any([context?.signal, runCancellationSignal(context)].filter((each) => each !== void 0))
+		});
+		if ("failure" in shared) {
+			reportError(shared.failure.message, shared.failure.remedy);
+			return failedResult({
+				code: shared.failure.code,
+				diagnostics: [{
+					message: shared.failure.message,
+					remedy: shared.failure.remedy
+				}],
+				durationMs: elapsed()
+			});
+		}
+		cacheClaim = shared.claim;
+		declareSpawnsOn(context, cacheClaim);
+	}
+	const releaseCache = () => {
+		stopDeclaringSpawnsOn(context, cacheClaim);
+		(0, ownership_claim_exports.releaseClaim)(cacheClaim);
+	};
+	let child;
+	try {
+		child = spawnDeclared(context, () => executor.spawn("xcodebuild", args, {
+			cwd: resolvedTarget.dir || root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: false,
+			env: {
+				...context?.env ?? process.env,
+				NSUnbufferedIO: "YES",
+				FORCE_COLOR: "0"
+			}
+		}));
+	} catch (err) {
+		releaseCache();
+		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
+		}));
+	});
+	releaseCache();
+	stopHeartbeat();
+	const durationMs = elapsed();
+	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,
+			tail,
+			compilationCache: compilationCacheActivity
+		});
+	}
+	if (outcome.code !== 0) {
+		const diagnostics = diagnosticCollector.diagnostics;
+		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,
+			tail,
+			compilationCache: compilationCacheActivity,
+			compilationCacheCorruption
+		});
+	}
+	const products = productsDir(dd, {
+		configuration,
+		sdk
+	});
+	let appPath = null;
+	if (scheme) try {
+		const targets = JSON.parse(await probe(executor, "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;
+			if (applicationTarget && (settings.TARGET_NAME !== applicationTarget.name || typeof settings.PROJECT_FILE_PATH !== "string" || realpathSync(settings.PROJECT_FILE_PATH) !== realpathSync(applicationTarget.projectPath))) 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,
+			tail,
+			compilationCache: compilationCacheActivity
+		});
+	}
+	const bundleId = await 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,
+			tail,
+			compilationCache: compilationCacheActivity
+		});
+	}
+	logWriter.write({
+		src: "build",
+		level: "info",
+		msg: `BUILD SUCCEEDED ${appPath} (${bundleId}) in ${durationMs}ms`,
+		event: "build_done"
+	});
+	return {
+		ok: true,
+		appPath,
+		bundleId,
+		durationMs,
+		scheme: buildScheme,
+		project: resolvedTarget,
+		derivedDataPath: dd,
+		productsDir: products,
+		transcriptLines,
+		compilationCache: compilationCacheActivity
+	};
+}
+//#endregion
+//#region src/engine/deps.ts
+const DEPS_ERROR = "STIM_DEPS_FAILED";
+const BUILD_MARKER = ".last_build_configuration";
+const TRANSCRIPT_LINES = 2e3;
+const MAX_POD_DIAGNOSTIC_LINES = 15;
+const POD_MARKER = /^\[!\]/;
+const POD_CONTINUATION = /^\s+\S/;
+const RUBY_HEAD = /^\S.*\.rb:\d+:in\s+(?:`[^']*'|'[^']*'):\s*\S/;
+const RUBY_FRAME = /^\s*from\s+\S/;
+const RUBY_CONTEXT_BEFORE = 4;
+const BUNDLER_FROZEN = /frozen mode|lockfile can't be updated|in deployment mode after changing/i;
+const BUNDLER_NO_COCOAPODS = /cocoapods is not currently included in the bundle|command not found: pod\b/i;
+function extractPodDiagnostics(transcript) {
+	if (typeof transcript !== "string" || transcript === "") return null;
+	const lines = transcript.split("\n").map((line) => line.replace(/\r$/, ""));
+	return extractPodBangBlocks(lines) || extractRubyHead(lines);
+}
+function extractPodBangBlocks(lines) {
+	const blocks = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line === void 0 || !POD_MARKER.test(line)) continue;
+		const block = [line];
+		let j = i + 1;
+		for (; j < lines.length; j += 1) {
+			const next = lines[j];
+			if (next === void 0 || !POD_CONTINUATION.test(next)) break;
+			block.push(next);
+		}
+		blocks.push(block);
+		i = j - 1;
+	}
+	if (blocks.length === 0) return null;
+	const out = [];
+	let dropped = 0;
+	for (const block of blocks) {
+		const room = MAX_POD_DIAGNOSTIC_LINES - out.length;
+		if (room <= 0) {
+			dropped += block.length;
+			continue;
+		}
+		out.push(...block.slice(0, room));
+		dropped += Math.max(0, block.length - room);
+	}
+	if (dropped > 0) out.push(`(+${dropped} more [!] lines in the build log)`);
+	return {
+		source: "cocoapods",
+		lines: out
+	};
+}
+function extractRubyHead(lines) {
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line === void 0 || !RUBY_HEAD.test(line) || RUBY_FRAME.test(line)) continue;
+		let start = i;
+		while (start > 0 && i - start < RUBY_CONTEXT_BEFORE) {
+			const prev = lines[start - 1];
+			if (prev === void 0 || prev.trim() === "" || RUBY_FRAME.test(prev) || POD_MARKER.test(prev)) break;
+			start -= 1;
+		}
+		let end = i + 1;
+		while (end < lines.length) {
+			const next = lines[end];
+			if (next === void 0 || next.trim() === "" || RUBY_FRAME.test(next)) break;
+			end += 1;
+		}
+		return {
+			source: "ruby",
+			lines: lines.slice(start, end).filter((entry) => entry.trim() !== "").slice(0, MAX_POD_DIAGNOSTIC_LINES)
+		};
+	}
+	return null;
+}
+function podsAreStale(lockText, manifestText, dir = "ios/") {
+	const lock = normalize(lockText);
+	const manifest = normalize(manifestText);
+	if (lock === null && manifest === null) return {
+		noPods: true,
+		stale: false
+	};
+	if (lock === null) return {
+		stale: true,
+		reason: `${dir}Podfile.lock is missing but ${dir}Pods exists`
+	};
+	if (manifest === null) return {
+		stale: true,
+		reason: `${dir}Pods/Manifest.lock is missing (pods have never been installed here)`
+	};
+	if (lock !== manifest) return {
+		stale: true,
+		reason: `${dir}Podfile.lock and ${dir}Pods/Manifest.lock differ`
+	};
+	return { stale: false };
+}
+function normalize(text) {
+	if (typeof text !== "string") return null;
+	return text.replace(/\r\n/g, "\n").trimEnd();
+}
+function readPodState(root, directory = join(root, "ios")) {
+	const rel = relative(root, directory);
+	return {
+		hasPodfile: existsSync(join(directory, "Podfile")),
+		lockText: readOrNull(join(directory, "Podfile.lock")),
+		manifestText: readOrNull(join(directory, "Pods", "Manifest.lock")),
+		dir: rel ? `${rel}/` : ""
+	};
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+const LOGIN_ENV_BEGIN = "@@ruby-env-begin@@";
+const LOGIN_ENV_END = "@@ruby-env-end@@";
+const LOGIN_ENV_SCRIPT = `printf '\\n${LOGIN_ENV_BEGIN}\\nPATH=%s\\nGEM_HOME=%s\\nGEM_PATH=%s\\n${LOGIN_ENV_END}\\n' "\$PATH" "\$GEM_HOME" "\$GEM_PATH" > "\$1"`;
+function parseLoginRubyEnv(output) {
+	const lines = output.split("\n").map((line) => line.replace(/\r$/, ""));
+	const begin = lines.lastIndexOf(LOGIN_ENV_BEGIN);
+	const end = lines.indexOf(LOGIN_ENV_END, begin + 1);
+	if (begin < 0 || end < 0) return null;
+	const out = {};
+	for (const line of lines.slice(begin + 1, end)) {
+		const eq = line.indexOf("=");
+		if (eq < 0) continue;
+		const key = line.slice(0, eq);
+		const value = line.slice(eq + 1);
+		if (value && (key === "PATH" || key === "GEM_HOME" || key === "GEM_PATH")) out[key] = value;
+	}
+	return out;
+}
+const loginRubyEnvByEnvironment = /* @__PURE__ */ new WeakMap();
+const LOGIN_ENV_OPTIONS = {
+	timeoutMs: 1e4,
+	killSignal: "SIGKILL",
+	detachedSilent: true
+};
+async function readLoginRubyEnvAsync(shell = ambientEnv().SHELL, platform = process.platform) {
+	const context = ambientContext();
+	context?.signal.throwIfAborted();
+	if (platform !== "darwin" || !shell || !isAbsolute(shell)) return null;
+	const environment = ambientEnv();
+	let cache = loginRubyEnvByEnvironment.get(environment);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		loginRubyEnvByEnvironment.set(environment, cache);
+	}
+	if (cache.has(shell)) return cache.get(shell) ?? null;
+	let dir = null;
+	let parsed = null;
+	try {
+		dir = mkdtempSync(join(tmpdir(), "stim-ruby-env-"));
+		const file = join(dir, "env");
+		await getExecutor().runFileAsync(shell, [
+			"-lic",
+			LOGIN_ENV_SCRIPT,
+			"stim",
+			file
+		], {
+			...LOGIN_ENV_OPTIONS,
+			declareFor: context,
+			onSpawn: killOnAbort(context?.signal)
+		});
+		parsed = parseLoginRubyEnv(readFileSync(file, "utf-8"));
+	} catch {
+		parsed = null;
+	} finally {
+		if (dir) rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+	context?.signal.throwIfAborted();
+	cache.set(shell, parsed);
+	return parsed;
+}
+function rubyPathEntries(login, callerPath, exists) {
+	const have = new Set((callerPath ?? "").split(delimiter));
+	const gemDirs = [login.GEM_HOME, ...(login.GEM_PATH ?? "").split(delimiter)].filter((dir) => !!dir);
+	return (login.PATH ?? "").split(delimiter).filter((entry) => {
+		if (!entry || have.has(entry)) return false;
+		if (gemDirs.some((gem) => entry === gem || entry.startsWith(gem + sep))) return true;
+		return exists(join(entry, "ruby")) || exists(join(entry, "pod"));
+	});
+}
+function prependPath(entries, existing) {
+	const seen = /* @__PURE__ */ new Set();
+	return [...entries, ...(existing ?? "").split(delimiter)].filter((entry) => entry && !seen.has(entry) && seen.add(entry)).join(delimiter);
+}
+function podEnvForRuby(version, { env = ambientEnv(), home = (process.platform === "win32" ? env.USERPROFILE : env.HOME) || homedir(), exists = existsSync, read = readOrNull, loginEnv = () => null } = {}) {
+	const out = {
+		...env,
+		FORCE_COLOR: "0",
+		CLICOLOR: "0",
+		LANG: env.LANG ?? "en_US.UTF-8",
+		LC_ALL: env.LC_ALL ?? env.LANG ?? "en_US.UTF-8"
+	};
+	const candidates = version ? [
+		{ bin: join(home, ".rbenv", "versions", version, "bin") },
+		{
+			bin: join(home, ".rvm", "rubies", `ruby-${version}`, "bin"),
+			rvm: `ruby-${version}`
+		},
+		{ bin: join(home, ".asdf", "installs", "ruby", version, "bin") },
+		{ bin: join(home, ".local", "share", "mise", "installs", "ruby", version, "bin") }
+	] : [];
+	for (const c of candidates) {
+		if (!exists(c.bin)) continue;
+		if (c.rvm) {
+			const rvm = rvmRuby(join(home, ".rvm"), c.rvm, exists);
+			out.PATH = prependPath(rvm.bins, out.PATH);
+			if (exists(rvm.gems.home)) {
+				out.GEM_HOME = rvm.gems.home;
+				out.GEM_PATH = rvm.gems.path;
+			}
+			return out;
+		}
+		out.PATH = `${c.bin}${delimiter}${out.PATH ?? ""}`;
+		return out;
+	}
+	if (env.GEM_HOME) return out;
+	const fallback = defaultRuby(home, exists, read);
+	if (fallback) {
+		out.PATH = prependPath(fallback.bins, out.PATH);
+		if (fallback.gems) {
+			out.GEM_HOME = fallback.gems.home;
+			out.GEM_PATH = fallback.gems.path;
+		}
+		return out;
+	}
+	const login = loginEnv();
+	if (!login) return out;
+	const rubyPath = rubyPathEntries(login, out.PATH, exists);
+	if (rubyPath.length) out.PATH = prependPath(rubyPath, out.PATH);
+	if (login.GEM_HOME) out.GEM_HOME = login.GEM_HOME;
+	if (login.GEM_PATH) out.GEM_PATH = login.GEM_PATH;
+	return out;
+}
+/** What `rvm use <name>` sets: the gemset and its `@global` gemset on `GEM_PATH` and their `bin` directories on `PATH`. */
+function rvmRuby(rvm, name, exists) {
+	const gems = join(rvm, "gems", name);
+	const global = `${gems}@global`;
+	return {
+		bins: [
+			join(gems, "bin"),
+			join(global, "bin"),
+			join(rvm, "rubies", name, "bin")
+		].filter(exists),
+		gems: {
+			home: gems,
+			path: [gems, global].join(delimiter)
+		}
+	};
+}
+/**
+* The Ruby a new login shell makes the default, read from the version manager's files: rvm's `default` alias in
+* `~/.rvm/config/alias`, or rbenv's global `~/.rbenv/version`.
+*/
+function defaultRuby(home, exists, read) {
+	const rvm = join(home, ".rvm");
+	const alias = /^default=(\S+)$/m.exec(read(join(rvm, "config", "alias")) ?? "")?.[1];
+	if (alias && exists(join(rvm, "rubies", alias, "bin"))) return rvmRuby(rvm, alias, exists);
+	const rbenv = read(join(home, ".rbenv", "version"))?.trim();
+	if (rbenv && exists(join(home, ".rbenv", "versions", rbenv, "bin"))) return { bins: [join(home, ".rbenv", "versions", rbenv, "bin")] };
+	return null;
+}
+async function podEnvForRubyAsync(version) {
+	let loginNeeded = false;
+	const withoutLogin = podEnvForRuby(version, { loginEnv: () => {
+		loginNeeded = true;
+		return null;
+	} });
+	if (!loginNeeded) return withoutLogin;
+	const login = await readLoginRubyEnvAsync();
+	return podEnvForRuby(version, { loginEnv: () => login });
+}
+function readRubyVersion(root, { read = readFileSync } = {}) {
+	try {
+		const first = String(read(join(root, ".ruby-version"), "utf-8")).split("\n").map((l) => l.trim()).find((l) => l && !l.startsWith("#"));
+		if (!first) return null;
+		return first.replace(/^ruby-/, "");
+	} catch {
+		return null;
+	}
+}
+async function bundlerEnv(root, gemfile) {
+	return {
+		...await podEnvForRubyAsync(readRubyVersion(root)),
+		BUNDLE_GEMFILE: gemfile,
+		BUNDLE_FROZEN: "true"
+	};
+}
+const BUNDLE_PATH_SETTING = /^BUNDLE_PATH:[ \t]*["']?([^"'\r\n]+?)["']?[ \t]*$/m;
+function bundlePathInsideProject(root, env) {
+	const fromEnv = env.BUNDLE_PATH;
+	const configured = fromEnv || BUNDLE_PATH_SETTING.exec(readOrNull(join(root, ".bundle", "config")) ?? "")?.[1];
+	if (!configured || configured.startsWith("~")) return null;
+	const resolved = resolve(root, configured);
+	if (resolved !== root && !resolved.startsWith(root + sep)) return null;
+	return {
+		path: relative(root, resolved) || ".",
+		where: fromEnv ? "where the BUNDLE_PATH environment variable points" : "where its own .bundle/config points BUNDLE_PATH"
+	};
+}
+async function runCaptured(ctx) {
+	const startedAt = ctx.now();
+	const transcript = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		transcript.push(msg);
+		if (transcript.length > TRANSCRIPT_LINES) transcript.splice(TRANSCRIPT_LINES / 2, 1);
+		ctx.logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: ctx.event
+		});
+	};
+	let child;
+	try {
+		child = spawnDeclared(ambientContext(), () => ctx.spawn(ctx.cmd, ctx.args, {
+			cwd: ctx.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: ctx.env
+		}));
+	} catch (error) {
+		return {
+			transcript,
+			code: null,
+			signal: null,
+			error,
+			durationMs: ctx.now() - startedAt
+		};
+	}
+	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 = ctx.label ? startBuildHeartbeat({
+		intervalMs: ctx.heartbeatMs,
+		elapsed: () => ctx.now() - startedAt,
+		emit: ctx.onHeartbeat,
+		label: ctx.label,
+		estimateMs: ctx.estimateMs ?? null
+	}) : () => {};
+	let result;
+	try {
+		result = await waitForChild(child);
+	} finally {
+		stopHeartbeat();
+	}
+	reader.out.flush();
+	reader.err.flush();
+	return {
+		transcript,
+		code: result.code ?? null,
+		signal: result.signal ?? null,
+		error: result.error ?? null,
+		durationMs: ctx.now() - startedAt
+	};
+}
+async function ensureBundledGems(root, pin, ctx) {
+	const env = await bundlerEnv(root, pin.gemfile);
+	const cwd = dirname(pin.gemfile);
+	const check = await runCaptured({
+		...ctx,
+		cmd: "bundle",
+		args: ["check", "--dry-run"],
+		cwd,
+		env,
+		event: "bundle_check",
+		label: "gems"
+	});
+	if (check.error) return bundlerSpawnFailure("bundle check", check, pin);
+	if (check.code === 0) return { bundler: true };
+	const install = await runCaptured({
+		...ctx,
+		cmd: "bundle",
+		args: ["install"],
+		cwd,
+		env,
+		event: "bundle_install",
+		label: "gems"
+	});
+	if (install.error) return bundlerSpawnFailure("bundle install", install, pin);
+	const inProject = bundlePathInsideProject(cwd, env);
+	const note = inProject ? `\`bundle install\` put this project's gems in ${inProject.path}${sep}, ${inProject.where}; Gemfile.lock itself is never written.` : void 0;
+	if (install.code === 0) return {
+		bundler: true,
+		note
+	};
+	const how = install.signal ? `signal ${install.signal}` : `exit code ${install.code}`;
+	const transcript = install.transcript.join("\n");
+	const extracted = extractPodDiagnostics(transcript);
+	return {
+		bundler: false,
+		failure: {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `\`bundle install\` failed (${how}).`,
+			remedy: frozenRemedy(pin, transcript) || gemInstallRemedy(root, pin),
+			diagnosticSource: extracted ? extracted.source : "tail",
+			diagnosticLines: extracted ? extracted.lines : [],
+			lastLines: install.transcript.slice(-20),
+			durationMs: install.durationMs
+		}
+	};
+}
+function bundlerSpawnFailure(command, run, pin) {
+	if (isMissingBinary(run.error)) return {
+		bundler: false,
+		note: missingBundlerNote(pin)
+	};
+	return {
+		bundler: false,
+		failure: {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `Could not run \`${command}\`: ${run.error?.message || run.error}`,
+			remedy: `Bundler is how this project pins its CocoaPods (${pin.lockfile}). Check that \`bundle\` runs in ${dirname(pin.gemfile)}, then run again.`,
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		}
+	};
+}
+function missingBundlerNote(pin) {
+	return `${pin.lockfile} pins this project's CocoaPods, but \`bundle\` is not on PATH, so pods run as plain \`pod install\` with whatever CocoaPods PATH resolves to (\`gem install bundler\` to use the pin).`;
+}
+function frozenRemedy(pin, transcript) {
+	if (!BUNDLER_FROZEN.test(transcript)) return void 0;
+	return `Stim runs bundler with BUNDLE_FROZEN so it can never write into your checkout, and ${pin.gemfile} no longer matches ${pin.lockfile}. Run \`cd ${dirname(pin.gemfile)} && bundle install\` yourself, keep the updated Gemfile.lock, then run again.`;
+}
+function gemInstallRemedy(root, pin) {
+	const version = readRubyVersion(root);
+	return `${version ? `This repo pins ruby ${version} (.ruby-version), so put that ruby on PATH (rbenv/rvm/asdf/mise) first. ` : ""}Bundler could not install the gems ${pin.lockfile} pins, so \`bundle exec pod install\` cannot run. Run \`cd ${dirname(pin.gemfile)} && bundle install\` and fix what it reports, then run again.`;
+}
+function readBuildMarkers(podsDir) {
+	let names;
+	try {
+		names = readdirSync(podsDir);
+	} catch {
+		return [];
+	}
+	return names.flatMap((name) => {
+		const dir = join(podsDir, name);
+		try {
+			return [{
+				dir,
+				ino: statSync(dir).ino,
+				content: readFileSync(join(dir, BUILD_MARKER))
+			}];
+		} catch {
+			return [];
+		}
+	});
+}
+function restoreBuildMarkers(markers) {
+	const restored = [];
+	for (const { dir, ino, content } of markers) {
+		const file = join(dir, BUILD_MARKER);
+		try {
+			if (existsSync(file) || statSync(dir).ino !== ino) continue;
+			writeFileSync(file, content);
+			restored.push(basename(dir));
+		} catch {}
+	}
+	return restored;
+}
+async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), directory = join(root, "ios") } = {}) {
+	const iosDir = directory;
+	if (!existsSync(iosDir)) return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: `No ${relative(root, iosDir) || "."}/ directory in ${root}, so there is nothing to pod install.`,
+		remedy: "Run `stim ios` on a project with native iOS sources, or let prebuild generate them.",
+		lastLines: []
+	};
+	const ctx = {
+		logWriter,
+		spawn: spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)),
+		now,
+		heartbeatMs,
+		onHeartbeat
+	};
+	const notes = [];
+	const pin = bundlerPin(root, iosDir);
+	let bundler = false;
+	if (pin) {
+		const gems = await ensureBundledGems(root, pin, ctx);
+		if (gems.failure) return {
+			...gems.failure,
+			notes
+		};
+		if (gems.note) notes.push(gems.note);
+		bundler = gems.bundler;
+	}
+	const args = bundler ? [
+		"bundle",
+		"exec",
+		"pod",
+		"install"
+	] : ["pod", "install"];
+	const command = args.join(" ");
+	const markers = readBuildMarkers(join(iosDir, "Pods"));
+	const run = await runCaptured({
+		...ctx,
+		cmd: args[0],
+		args: args.slice(1),
+		cwd: iosDir,
+		env: bundler && pin ? await bundlerEnv(root, pin.gemfile) : await podEnvForRubyAsync(readRubyVersion(root)),
+		event: "pod_install",
+		label: "pods",
+		estimateMs
+	});
+	const restored = restoreBuildMarkers(markers);
+	if (restored.length) notes.push(`kept the ${BUILD_MARKER} that pod install removed from ${restored.join(", ")}`);
+	if (run.error) return {
+		...(bundler ? missingBundle(run.error, pin) : missingPod(run.error)) || {
+			failed: true,
+			code: "STIM_DEPS_FAILED",
+			reason: `Could not run \`${command}\`: ${run.error?.message || run.error}`,
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		},
+		command,
+		notes
+	};
+	if (run.code !== 0) {
+		const how = run.signal ? `signal ${run.signal}` : `exit code ${run.code}`;
+		const transcript = run.transcript.join("\n");
+		const extracted = extractPodDiagnostics(transcript);
+		return {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `\`${command}\` failed (${how}).`,
+			remedy: podFailureRemedy(root, pin, transcript),
+			command,
+			notes,
+			diagnosticSource: extracted ? extracted.source : "tail",
+			diagnosticLines: extracted ? extracted.lines : [],
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		};
+	}
+	return {
+		ok: true,
+		command,
+		notes,
+		durationMs: run.durationMs
+	};
+}
+function podFailureRemedy(root, pin, transcript) {
+	if (pin) {
+		const frozen = frozenRemedy(pin, transcript);
+		if (frozen) return frozen;
+		if (BUNDLER_NO_COCOAPODS.test(transcript)) return `${pin.lockfile} resolves cocoapods, but bundler found no \`pod\` executable in the bundle it loaded: the installed gems belong to a different Gemfile than ${pin.gemfile}, or that Gemfile's bundle was never installed. Run \`cd ${dirname(pin.gemfile)} && bundle install && bundle exec pod --version\` and make that work, then run again.`;
+	}
+	const pinned = /Could not find proper version of cocoapods/.test(transcript) ? readRubyVersion(root) : null;
+	if (!pinned) return void 0;
+	return `This repo pins ruby ${pinned} (.ruby-version) and its Gemfile's cocoapods was installed under it; the shell's ruby is likely a different version, so bundler looks in the wrong gem home. Put ruby ${pinned} on PATH (rbenv/rvm/asdf/mise) -- \`bundle install\` will NOT fix this.`;
+}
+function isMissingBinary(err) {
+	const nodeErr = err;
+	const message = String(nodeErr?.message || err || "");
+	return nodeErr?.code === "ENOENT" || /ENOENT|not found/i.test(message);
+}
+function missingBundle(err, pin) {
+	if (!isMissingBinary(err)) return null;
+	return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: "Bundler is not installed: no `bundle` executable on PATH.",
+		remedy: `${pin?.lockfile ?? "Gemfile.lock"} pins this project's CocoaPods, so pods run through bundler. Install bundler (\`gem install bundler\`) and run again.`,
+		lastLines: []
+	};
+}
+const POD_MISSING_REASON = "CocoaPods is not installed: no `pod` executable on PATH.";
+function missingPod(err) {
+	if (!isMissingBinary(err)) return null;
+	return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: POD_MISSING_REASON,
+		remedy: "Install CocoaPods (`brew install cocoapods`, or `gem install cocoapods`) and run again.",
+		lastLines: []
+	};
+}
+//#endregion
+//#region src/offload/toolchain.ts
+const distDir = dirname(fileURLToPath(import.meta.url));
+/**
+* What a client and a remote machine must agree on to build for each other: what a worker builds and how, the
+* artifacts it returns and the build and artifact messages. It lives in the `stim` package, whose own code does the
+* build, because `@stim-cli/core` is a ranged dependency that can resolve newer than the installed `stim`.
+* `scripts/build-compat.json` records the files a change to which needs a bump or a recorded no-bump.
+*/
+const STIM_BUILD_COMPAT = 2;
+function quiet(file, args) {
+	return getExecutor().runFileQuiet(file, args, { timeoutMs: 2e4 });
+}
+async function quietAsync(file, args) {
+	try {
+		return await getExecutor().runFileAsync(file, args, { timeoutMs: 2e4 });
+	} catch {
+		return null;
+	}
+}
+/** This Mac's iOS toolchain, with the CocoaPods that `pod install` in `podDirectory` runs; null skips CocoaPods. */
+async function iosToolchainAsync(root, podDirectory) {
+	const [xcode, simulatorSdk, cocoapods] = await Promise.all([
+		quietAsync("xcodebuild", ["-version"]),
+		quietAsync("xcrun", [
+			"--sdk",
+			"iphonesimulator",
+			"--show-sdk-version"
+		]),
+		podDirectory === null ? null : projectCocoapodsVersion(root, podDirectory)
+	]);
+	return assembleIosToolchain(xcode, simulatorSdk, cocoapods);
+}
+function iosToolchainForRuby(rubyVersion, native) {
+	return assembleIosToolchain(quiet("xcodebuild", ["-version"]), quiet("xcrun", [
+		"--sdk",
+		"iphonesimulator",
+		"--show-sdk-version"
+	]), native ? null : cocoapodsVersion(rubyVersion));
+}
+function assembleIosToolchain(xcode, simulatorSdk, cocoapods) {
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		compat: STIM_BUILD_COMPAT,
+		arch: process.arch,
+		xcode: xcode ? xcode.trim().replace(/\n/g, " / ") : null,
+		simulatorSdk: simulatorSdk?.trim() ?? null,
+		cocoapods
+	};
+}
+function podProbeEnv(env) {
+	return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+}
+function podVersionLine(output) {
+	return output?.trim().split("\n").pop()?.trim() ?? null;
+}
+function cocoapodsVersion(rubyVersion) {
+	return podVersionLine(getExecutor().runFileQuiet("pod", ["--version"], {
+		timeoutMs: 2e4,
+		env: podProbeEnv(podEnvForRuby(rubyVersion))
+	}));
+}
+async function projectCocoapodsVersion(root, podDirectory) {
+	const pin = bundlerPin(root, podDirectory);
+	if (pin) return pin.cocoapods;
+	try {
+		return podVersionLine(await getExecutor().runFileAsync("pod", ["--version"], {
+			timeoutMs: 2e4,
+			cwd: podDirectory,
+			env: podProbeEnv(await podEnvForRubyAsync(readRubyVersion(root)))
+		}));
+	} catch {
+		return null;
+	}
+}
+function macosToolchain() {
+	return assembleMacosToolchain(quiet("xcodebuild", ["-version"]), quiet("xcrun", [
+		"--sdk",
+		"macosx",
+		"--show-sdk-version"
+	]));
+}
+async function macosToolchainAsync() {
+	const [xcode, macosSdk] = await Promise.all([quietAsync("xcodebuild", ["-version"]), quietAsync("xcrun", [
+		"--sdk",
+		"macosx",
+		"--show-sdk-version"
+	])]);
+	return assembleMacosToolchain(xcode, macosSdk);
+}
+function assembleMacosToolchain(xcode, macosSdk) {
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		compat: STIM_BUILD_COMPAT,
+		arch: process.arch,
+		xcode: xcode ? xcode.trim().replace(/\n/g, " / ") : null,
+		macosSdk: macosSdk?.trim() ?? null
+	};
+}
+/** The major version in a JDK's `release` file, as `JAVA_VERSION="17.0.19"` (or `"1.8.0_402"` for Java 8) gives it. */
+function jdkMajor(release) {
+	return /^JAVA_VERSION="(?:1\.)?(\d+)/m.exec(release)?.[1] ?? null;
+}
+function releaseMajor(home) {
+	try {
+		return jdkMajor(readFileSync(join(home, "release"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+/**
+* The JDK Gradle's wrapper picks: `JAVA_HOME`, else the `java` on PATH, which is the macOS `/usr/bin/java`
+* stub (resolved through `java_home`) unless a real JDK comes first.
+*/
+function localJdk(env = process.env) {
+	if (env.JAVA_HOME) return releaseMajor(env.JAVA_HOME);
+	const java = getExecutor().findExecutable("java");
+	if (java) try {
+		const fromPath = releaseMajor(dirname(dirname(realpathSync(java))));
+		if (fromPath) return fromPath;
+	} catch {}
+	const home = quiet("/usr/libexec/java_home", [])?.trim();
+	return home ? releaseMajor(home) : null;
+}
+/** Where JDKs install, as `JAVA_HOME` values: the one in `env` first, then the usual locations of `platform`. */
+function jdkCandidates(env = process.env, platform = process.platform, home = homedir()) {
+	const out = env.JAVA_HOME ? [env.JAVA_HOME] : [];
+	const children = (dir) => (listDir(dir) ?? []).map((entry) => join(dir, entry));
+	out.push(...children(join(home, ".sdkman", "candidates", "java")));
+	if (platform === "darwin") {
+		for (const dir of ["/Library/Java/JavaVirtualMachines", join(home, "Library", "Java", "JavaVirtualMachines")]) out.push(...children(dir).map((jvm) => join(jvm, "Contents", "Home")));
+		for (const prefix of ["/opt/homebrew", "/usr/local"]) for (const formula of children(join(prefix, "opt")).filter((dir) => /^openjdk(@\d+)?$/.test(basename(dir)))) out.push(join(formula, "libexec", "openjdk.jdk", "Contents", "Home"));
+		for (const app of children("/Applications").filter((dir) => basename(dir).startsWith("Android Studio"))) out.push(join(app, "Contents", "jbr", "Contents", "Home"));
+	} else if (platform === "win32") {
+		const programs = env.ProgramFiles ?? "C:\\Program Files";
+		for (const vendor of [
+			"Eclipse Adoptium",
+			"Java",
+			"Microsoft",
+			"Zulu",
+			"Android"
+		]) out.push(...children(join(programs, vendor)));
+		out.push(join(programs, "Android", "Android Studio", "jbr"));
+	} else out.push(...children("/usr/lib/jvm"), ...children("/opt").map((dir) => join(dir, "jbr")));
+	return out;
+}
+/** The first home of each JDK major among `candidates`, read from each `release` file; a home without `javac` is a JRE. */
+function jdkHomes(candidates) {
+	const homes = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const major = releaseMajor(candidate);
+		const javac = join(candidate, "bin", process.platform === "win32" ? "javac.exe" : "javac");
+		if (major && !homes.has(major) && existsSync(javac)) homes.set(major, candidate);
+	}
+	return homes;
+}
+function installedJdkMajors() {
+	const majors = new Set(jdkHomes(jdkCandidates()).keys());
+	const current = localJdk();
+	if (current) majors.add(current);
+	return [...majors].toSorted((a, b) => Number(a) - Number(b));
+}
+/**
+* Points this process, and the Gradle it starts, at an installed JDK of `major` when its default JDK is another one.
+* Returns why it cannot, or null.
+*/
+function useJdkMajor(major, env = process.env, candidates = jdkCandidates(env)) {
+	if (localJdk(env) === major) return null;
+	const home = jdkHomes(candidates).get(major);
+	if (!home) return `This machine has no JDK ${major} to build on.`;
+	env.JAVA_HOME = home;
+	return null;
+}
+function androidToolchain() {
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		compat: STIM_BUILD_COMPAT,
+		arch: process.arch,
+		jdk: localJdk()
+	};
+}
+async function androidToolchainAsync(env = process.env) {
+	let jdk = null;
+	if (env.JAVA_HOME) jdk = releaseMajor(env.JAVA_HOME);
+	else {
+		const java = getExecutor().findExecutable("java");
+		if (java) try {
+			jdk = releaseMajor(dirname(dirname(realpathSync(java))));
+		} catch {}
+		if (!jdk) {
+			const home = (await quietAsync("/usr/libexec/java_home", []))?.trim();
+			if (home) jdk = releaseMajor(home);
+		}
+	}
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		compat: STIM_BUILD_COMPAT,
+		arch: process.arch,
+		jdk
+	};
+}
+/** `ndkVersion`, `buildTools` and `compileSdk` from React Native's `gradle/libs.versions.toml`. */
+function parseAndroidRequirements(catalog) {
+	const value = (key) => new RegExp(`^${key}\\s*=\\s*"([^"]+)"`, "m").exec(catalog)?.[1] ?? null;
+	return {
+		ndk: value("ndkVersion"),
+		buildTools: value("buildTools"),
+		compileSdk: value("compileSdk")
+	};
+}
+function sdkDownloadDisabled(properties) {
+	return /^\s*android\.builder\.sdkDownload\s*[=:]\s*false\s*$/im.test(properties);
+}
+function projectSdkDownload(gradleRoot) {
+	try {
+		return !sdkDownloadDisabled(readFileSync(join(gradleRoot, "gradle.properties"), "utf8"));
+	} catch {
+		return true;
+	}
+}
+function androidRequirements(projectRoot, gradleRoot = join(projectRoot, "android")) {
+	const sdkDownload = projectSdkDownload(gradleRoot) ? {} : { sdkDownload: false };
+	try {
+		const pkg = createRequire(join(projectRoot, "package.json")).resolve("react-native/package.json");
+		return {
+			...parseAndroidRequirements(readFileSync(join(dirname(pkg), "gradle", "libs.versions.toml"), "utf8")),
+			...sdkDownload
+		};
+	} catch {
+		return {
+			ndk: null,
+			buildTools: null,
+			compileSdk: null,
+			...sdkDownload
+		};
+	}
+}
+/** Runtime identifiers that have at least one available iPhone simulator, from `simctl list devices -j`. */
+function iphoneRuntimes(listed) {
+	const devices = listed?.devices;
+	if (!devices || typeof devices !== "object") return [];
+	return Object.entries(devices).filter(([, list]) => (Array.isArray(list) ? list : []).some(availableIphone)).map(([runtime]) => runtime).toSorted();
+}
+function availableIphone(device) {
+	return device.isAvailable === true && typeof device.deviceTypeIdentifier === "string" && device.deviceTypeIdentifier.startsWith("com.apple.CoreSimulator.SimDeviceType.iPhone-");
+}
+function listDir(path) {
+	try {
+		return readdirSync(path).filter((entry) => !entry.startsWith(".")).toSorted();
+	} catch {
+		return null;
+	}
+}
+function sdkPackages() {
+	const sdk = androidHome();
+	const platforms = listDir(join(sdk, "platforms"));
+	if (!platforms) return null;
+	return {
+		ndk: listDir(join(sdk, "ndk")) ?? [],
+		buildTools: listDir(join(sdk, "build-tools")) ?? [],
+		platforms
+	};
+}
+/** `CFBundleShortVersionString` and `ProductBuildVersion` of an Xcode app's `Contents/version.plist`. */
+function parseXcodeVersionPlist(plist) {
+	const value = (key) => new RegExp(`<key>${key}</key>\\s*<string>([^<]+)</string>`).exec(plist)?.[1] ?? null;
+	return {
+		version: value("CFBundleShortVersionString"),
+		build: value("ProductBuildVersion")
+	};
+}
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+const realPathOrNull = (path) => path ? realPath(path) : null;
+function listXcodeApps(checks, root = "/Applications") {
+	const apps = [];
+	for (const entry of listDir(root) ?? []) {
+		if (!entry.endsWith(".app") || !existsSync(join(root, entry, "Contents", "Developer"))) continue;
+		const path = realPath(join(root, entry));
+		if (apps.some((each) => each.path === path)) continue;
+		let plist = "";
+		try {
+			plist = readFileSync(join(path, "Contents", "version.plist"), "utf8");
+		} catch {}
+		const app = {
+			path,
+			...parseXcodeVersionPlist(plist)
+		};
+		if (checks) {
+			const env = {
+				...process.env,
+				DEVELOPER_DIR: join(path, "Contents", "Developer")
+			};
+			const passes = (args) => getExecutor().runFileQuiet("xcodebuild", args, {
+				timeoutMs: 2e4,
+				env
+			}) !== null;
+			app.license = passes(["-license", "check"]);
+			app.firstLaunch = passes(["-checkFirstLaunchStatus"]);
+		}
+		apps.push(app);
+	}
+	return apps;
+}
+function xcodeSelectionReport(xcode) {
+	if (process.env.DEVELOPER_DIR) return {};
+	return {
+		developerDir: realPathOrNull(quiet("xcode-select", ["-p"])?.trim() || null),
+		xcodeApps: listXcodeApps(xcode === null)
+	};
+}
+/** Whether the SDK's licenses are accepted: Gradle's SDK download reads `licenses/android-sdk-license`. */
+function sdkLicensesAccepted(sdk) {
+	try {
+		return readFileSync(join(sdk, "licenses", "android-sdk-license"), "utf8").trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+function sdkReport() {
+	const androidSdk = sdkPackages();
+	if (!androidSdk) return { androidSdk };
+	const home = androidHome();
+	return {
+		androidSdk,
+		androidLicenses: sdkLicensesAccepted(home),
+		androidHome: home
+	};
+}
+function workerToolchain(rubyVersion = null, native) {
+	if (native === "gradle") return {
+		...androidToolchain(),
+		os: process.platform,
+		xcode: null,
+		simulatorSdk: null,
+		cocoapods: null,
+		macosSdk: null,
+		bundler: null,
+		runtimes: [],
+		jdks: installedJdkMajors(),
+		...sdkReport()
+	};
+	let listed = null;
+	try {
+		listed = JSON.parse(quiet("xcrun", [
+			"simctl",
+			"list",
+			"devices",
+			"available",
+			"-j"
+		]) ?? "null");
+	} catch {}
+	const ios = iosToolchainForRuby(rubyVersion, native);
+	return {
+		...ios,
+		...process.platform === "darwin" ? xcodeSelectionReport(ios.xcode) : {},
+		os: process.platform,
+		macosSdk: native ? null : quiet("xcrun", [
+			"--sdk",
+			"macosx",
+			"--show-sdk-version"
+		])?.trim() ?? null,
+		bundler: native ? null : quiet("bundle", ["--version"])?.trim() || null,
+		runtimes: iphoneRuntimes(listed),
+		jdk: native ? null : localJdk(),
+		...native ? {} : { jdks: installedJdkMajors() },
+		...native ? { androidSdk: null } : sdkReport()
+	};
+}
+/** The API level of an SDK `platforms/` directory: `android-37.0` and `android-37` are both 37. */
+const platformLevel = (dir) => dir.replace(/^android-/, "").split(".")[0];
+function sdkGaps(requires, sdk) {
+	const gaps = [];
+	if (requires.ndk && !sdk.ndk.includes(requires.ndk)) gaps.push({
+		code: "ndk",
+		label: `NDK ${requires.ndk}`,
+		id: `ndk;${requires.ndk}`,
+		size: "about 1-2 GB"
+	});
+	if (requires.buildTools && !sdk.buildTools.includes(requires.buildTools)) gaps.push({
+		code: "build-tools",
+		label: `build-tools ${requires.buildTools}`,
+		id: `build-tools;${requires.buildTools}`
+	});
+	if (requires.compileSdk && !sdk.platforms.some((dir) => platformLevel(dir) === requires.compileSdk)) gaps.push({
+		code: "compile-sdk",
+		label: `platform android-${requires.compileSdk}`,
+		id: `platforms;android-${requires.compileSdk}`
+	});
+	return gaps;
+}
+/** Whether Gradle downloads a package the worker's SDK lacks: its licenses are accepted and the project allows it. */
+function gradleDownloads(requires, worker) {
+	return worker.androidLicenses === true && requires.sdkDownload !== false;
+}
+function shellQuote(path, os) {
+	if (/^[\w@%+=:,./\\~-]+$/.test(path)) return path;
+	return os === "win32" ? `"${path}"` : `'${path.replaceAll("'", "'\\''")}'`;
+}
+function sdkManagerPath(worker) {
+	if (!worker.androidHome) return "sdkmanager";
+	return shellQuote(worker.os === "win32" ? `${worker.androidHome}\\cmdline-tools\\latest\\bin\\sdkmanager.bat` : `${worker.androidHome}/cmdline-tools/latest/bin/sdkmanager`, worker.os);
+}
+function jdkInstall(major, os) {
+	return {
+		commands: [os === "linux" ? `sudo apt install openjdk-${major}-jdk-headless` : os === "win32" ? `winget install EclipseAdoptium.Temurin.${major}.JDK` : `brew install --cask zulu@${major}`],
+		lead: `install JDK ${major}; Stim uses it automatically, no restart needed`
+	};
+}
+function androidMismatches(local, requires, worker) {
+	const out = [];
+	if ((!local.jdk || worker.jdk !== local.jdk) && !(local.jdk && worker.jdks?.includes(local.jdk))) out.push({
+		code: "jdk",
+		reason: `JDK ${worker.jdk ?? "none"} there, ${local.jdk ?? "none"} here`,
+		...local.jdk && worker.jdks ? jdkInstall(local.jdk, worker.os) : {}
+	});
+	const sdk = worker.androidSdk;
+	if (!sdk) return [...out, {
+		code: "android-sdk",
+		reason: "no Android SDK there"
+	}];
+	if (gradleDownloads(requires, worker)) return out;
+	const sdkManager = sdkManagerPath(worker);
+	const why = requires.sdkDownload === false ? ", and the project sets android.builder.sdkDownload=false" : worker.androidLicenses === false ? ", and its SDK licenses are not accepted" : "";
+	for (const gap of sdkGaps(requires, sdk)) {
+		const install = `${sdkManager} "${gap.id}"`;
+		const licenses = worker.androidLicenses === false && requires.sdkDownload !== false;
+		out.push({
+			code: gap.code,
+			reason: `no ${gap.label} there${why}`,
+			commands: licenses ? [`${sdkManager} --licenses`, install] : [install],
+			lead: licenses ? "accept the SDK licenses so Gradle downloads the package, or install it" : worker.androidHome ? "install the package into its Android SDK" : "install the package into the Android SDK stim-server uses (its ANDROID_HOME, else the default SDK location)"
+		});
+	}
+	return out;
+}
+function cocoapodsInstall(here) {
+	return {
+		commands: ["brew install cocoapods"],
+		lead: here ? `install CocoaPods (this Mac has ${here}; \`gem install cocoapods -v ${here}\` instead of Homebrew installs that version)` : "install CocoaPods"
+	};
+}
+function cocoapodsDifference(target, worker) {
+	if (target.native || target.cocoapodsPinned) return null;
+	if (worker.os !== void 0 && worker.os !== "darwin") return null;
+	const here = target.local.cocoapods;
+	if (!worker.cocoapods) return {
+		code: "cocoapods",
+		reason: versionMismatch("CocoaPods", null, here),
+		...cocoapodsInstall(here)
+	};
+	return here && worker.cocoapods !== here ? {
+		code: "cocoapods",
+		reason: versionMismatch("CocoaPods", worker.cocoapods, here)
+	} : null;
+}
+/**
+* What a build on the worker does beyond the match: the SDK packages it lacks and Gradle downloads on the first build,
+* because its SDK licenses are accepted and the project allows the download. None of them stops the build. For iOS, the
+* CocoaPods difference a named machine is sent the build despite.
+*/
+function toolchainNotes(target, worker) {
+	if (target.platform === "ios") {
+		const pods = cocoapodsDifference(target, worker);
+		return pods ? [{
+			...pods,
+			reason: `${pods.reason}; its pod install runs anyway and a failure is reported`
+		}] : [];
+	}
+	if (target.platform !== "android" || !worker.androidSdk || !gradleDownloads(target.requires, worker)) return [];
+	const sdkManager = sdkManagerPath(worker);
+	return sdkGaps(target.requires, worker.androidSdk).map((gap) => ({
+		code: gap.code,
+		reason: `${gap.label} is not installed there; Gradle downloads it on the first build${gap.size ? ` (${gap.size})` : ""}`,
+		commands: [`${sdkManager} "${gap.id}"`],
+		lead: "install the package now so the first build does not download it"
+	}));
+}
+function versionMismatch(tool, there, here) {
+	const side = (version) => version ? version.startsWith(tool) ? version : `${tool} ${version}` : `no ${tool}`;
+	return `${side(there)} there, ${side(here)} here`;
+}
+const COMMAND_LINE_TOOLS = "/Library/Developer/CommandLineTools";
+function xcodeIdentity(xcode) {
+	return {
+		version: xcode ? /Xcode (\S+)/.exec(xcode)?.[1] ?? null : null,
+		build: xcode ? /Build version (\S+)/.exec(xcode)?.[1] ?? null : null
+	};
+}
+const versionParts = (version) => (version ?? "").split(".").map((part) => Number.parseInt(part, 10) || 0);
+function compareVersions(a, b) {
+	const [left, right] = [versionParts(a), versionParts(b)];
+	for (let index = 0; index < Math.max(left.length, right.length); index++) {
+		const difference = (left[index] ?? 0) - (right[index] ?? 0);
+		if (difference) return difference;
+	}
+	return 0;
+}
+function pickXcodeApp(apps, wanted) {
+	return (wanted.build ? apps.find((app) => app.build === wanted.build) : void 0) ?? (wanted.version ? apps.find((app) => app.version === wanted.version) : void 0) ?? apps.toSorted((a, b) => compareVersions(b.version, a.version))[0];
+}
+const developerDirOf = (app) => posix.join(app.path, "Contents", "Developer");
+function selectXcode(app, selected, worker) {
+	const commands = selected ? [] : [`sudo xcode-select -s ${shellQuote(developerDirOf(app), worker.os)}`];
+	if (app.license === false && app.firstLaunch === false) commands.push("sudo xcodebuild -license accept && sudo xcodebuild -runFirstLaunch");
+	else if (app.license === false) commands.push("sudo xcodebuild -license accept");
+	else if (app.firstLaunch === false) commands.push("sudo xcodebuild -runFirstLaunch");
+	const name = basename(app.path, ".app");
+	return {
+		commands,
+		lead: selected ? `finish setting up ${name}` : `select ${name}${commands.length > 1 ? " and finish setting it up" : ""}`
+	};
+}
+function diagnosesXcode(local, worker) {
+	return worker.xcode === null && worker.developerDir !== void 0 && local.xcode !== null;
+}
+function xcodeProblem(local, worker, onWorker = false) {
+	const legacy = {
+		code: "xcode",
+		reason: onWorker ? "no Xcode there" : versionMismatch("Xcode", worker.xcode, local.xcode)
+	};
+	if (worker.developerDir === void 0 || !onWorker && !local.xcode) return legacy;
+	const wanted = onWorker ? {
+		version: null,
+		build: null
+	} : xcodeIdentity(local.xcode);
+	const apps = worker.xcodeApps ?? [];
+	if (worker.xcode) {
+		const match = wanted.build ? apps.find((app) => app.build === wanted.build) : void 0;
+		return match ? {
+			...legacy,
+			...selectXcode(match, false, worker)
+		} : legacy;
+	}
+	const app = pickXcodeApp(apps, wanted);
+	if (!app) return {
+		code: "xcode",
+		reason: "no Xcode there",
+		...wanted.version ? {
+			commands: [`xcodes install ${wanted.version}`],
+			lead: `install Xcode ${wanted.version} (from the App Store, or with xcodes), then run stim doctor again`
+		} : {}
+	};
+	const selected = worker.developerDir === developerDirOf(app);
+	const where = worker.developerDir ? worker.developerDir.startsWith(COMMAND_LINE_TOOLS) ? "Command Line Tools" : worker.developerDir : "nothing";
+	const fix = selectXcode(app, selected, worker);
+	const matches = app.build === wanted.build || app.version === wanted.version;
+	return {
+		code: "xcode",
+		reason: selected ? `no Xcode there: ${basename(app.path)} is selected${fix.commands?.length ? " but not set up" : " but xcodebuild fails"}` : `no Xcode there: xcode-select points at ${where}`,
+		...fix,
+		...wanted.version && !matches ? { lead: `${fix.lead} (this Mac has Xcode ${wanted.version}; xcodes install ${wanted.version} matches it)` } : {}
+	};
+}
+function runtimeProblem(runtime, worker, followsXcode) {
+	const reason = `no iPhone simulator on ${runtime} there`;
+	if (followsXcode) return {
+		code: "runtime",
+		reason: `${reason}; this follows from the Xcode problem`,
+		followsFrom: "xcode"
+	};
+	const version = /iOS-(\d+)-(\d+)$/.exec(runtime);
+	return worker.developerDir !== void 0 && version ? {
+		code: "runtime",
+		reason,
+		commands: [`xcodebuild -downloadPlatform iOS -buildVersion ${version[1]}.${version[2]}`],
+		lead: `download the iOS ${version[1]}.${version[2]} simulator runtime if it is not installed (an installed runtime also needs an iPhone simulator)`
+	} : {
+		code: "runtime",
+		reason
+	};
+}
+/** Why a remote machine cannot build like this machine; empty when it can. */
+function toolchainMismatches(target, worker) {
+	const { local } = target;
+	const out = [];
+	if (!local.stimBuild || (worker.compat !== void 0 ? worker.compat !== local.compat : worker.stimBuild !== local.stimBuild)) out.push({
+		code: "stim-build",
+		reason: `Stim build ${worker.stimBuild ?? "unknown"} there, ${local.stimBuild ?? "unknown"} here`
+	});
+	if (target.platform === "android") return [...out, ...androidMismatches(target.local, target.requires, worker)];
+	if (worker.os !== void 0 && worker.os !== "darwin") {
+		const name = target.platform === "ios" ? "iOS" : "macOS";
+		return [...out, {
+			code: "platform",
+			reason: `${worker.os} there, and ${name} builds need a Mac`
+		}];
+	}
+	if (target.platform === "macos" && target.runsOnWorker) {
+		if (!worker.xcode) out.push(xcodeProblem(target.local, worker, true));
+		if (!worker.macosSdk) out.push({
+			code: "macos-sdk",
+			reason: "no macOS SDK there"
+		});
+		return out;
+	}
+	if (worker.arch !== local.arch) out.push({
+		code: "arch",
+		reason: `CPU ${worker.arch} there, ${local.arch} here`
+	});
+	if (target.platform === "macos") {
+		const macos = target.local;
+		const xcode = !macos.xcode || worker.xcode !== macos.xcode ? xcodeProblem(macos, worker) : null;
+		if (xcode) out.push(xcode);
+		if ((!macos.macosSdk || worker.macosSdk !== macos.macosSdk) && !(xcode && diagnosesXcode(macos, worker))) out.push({
+			code: "macos-sdk",
+			reason: versionMismatch("macOS SDK", worker.macosSdk, macos.macosSdk)
+		});
+		return out;
+	}
+	const ios = target.local;
+	const xcode = !ios.xcode || worker.xcode !== ios.xcode ? xcodeProblem(ios, worker) : null;
+	if (xcode) out.push(xcode);
+	const selection = xcode !== null && diagnosesXcode(ios, worker);
+	if ((!ios.simulatorSdk || worker.simulatorSdk !== ios.simulatorSdk) && !selection) out.push({
+		code: "simulator-sdk",
+		reason: versionMismatch("simulator SDK", worker.simulatorSdk, ios.simulatorSdk)
+	});
+	if (!target.native && target.cocoapodsPinned && !worker.bundler) out.push({
+		code: "bundler",
+		reason: "no Bundler there to run the CocoaPods this project's Gemfile.lock pins"
+	});
+	if (target.runtime && !worker.runtimes.includes(target.runtime)) out.push(runtimeProblem(target.runtime, worker, selection || Boolean(xcode?.commands)));
+	return out;
+}
+//#endregion
+export { clearNativeRunCancel as $, COMPILATION_CACHE_UNAVAILABLE as A, readBundleExecutable as B, POD_MISSING_REASON as C, runCaptured as D, readRubyVersion as E, compilationCacheSettings as F, tailLines as G, resolveScheme as H, detectXcodeMajorAsync as I, bundlerPin as J, xcodebuildArgs as K, parseSwiftVersion as L, SWIFT_PREFIX_MAPPING_MIN_SWIFT as M, buildXcode as N, runPodInstall as O, compilationCacheActivityLine as P, cancelledFailure as Q, parseXcodeMajor as R, DEPS_ERROR as S, readPodState as T, startBuildHeartbeat as U, readBundleId as V, swiftPrefixMappingSupported as W, NATIVE_RUN_LOCK as X, podInstallCommand as Y, NATIVE_RUN_WAIT_MS as Z, sdkDownloadDisabled as _, cocoapodsDifference as a, runCancellation as at, useJdkMajor as b, iphoneRuntimes as c, cacheUser as ct, jdkMajor as d, decideStopAction as et, listXcodeApps as f, parseXcodeVersionPlist as g, parseAndroidRequirements as h, availableIphone as i, requestNativeRunCancel as it, HEARTBEAT_INTERVAL_MS as j, COMPILATION_CACHE_NOT_RUN as k, jdkCandidates as l, claimForEmptying as lt, macosToolchainAsync as m, androidToolchain as n, nativeRunHolder as nt, cocoapodsInstall as o, runCancellationSignal as ot, macosToolchain as p, describeDiagnostic as q, androidToolchainAsync as r, nativeRunWaitNotice as rt, iosToolchainAsync as s, withNativeBuildRun as st, androidRequirements as t, describeNativeRunHolder as tt, jdkHomes as u, toolchainMismatches as v, podsAreStale as w, workerToolchain as x, toolchainNotes as y, pickXcodeProject as z };