stim 1.20.2 → 1.22.0

package/dist/xcode-BXn9-xYx.mjs

@@ -0,0 +1,896 @@
+import { c as declareSpawnsOn, d as spawnDeclared, f as stopDeclaringSpawnsOn, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { u as workspaceDerivedData } from "./paths-DQtTgsBf.mjs";
+import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { a as killOnAbort } from "./operation-exec-BW0em61G.mjs";
+import { d as runCancellationSignal, h as shareCompilationCache } from "./native-run-NwUuxbkg.mjs";
+import { p as resolveOptimizations } from "./errors-ccaPc4ox.mjs";
+import { t as cleanLine } from "./server-expo-CrjB29pq.mjs";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { ambientContext } from "@stim-cli/core";
+//#region src/engine/bundler.ts
+const COCOAPODS_SPEC = /^ {4}cocoapods \(/m;
+function bundlerPin(root) {
+	const gemfile = join(root, "Gemfile");
+	const lockfile = join(root, "Gemfile.lock");
+	if (!existsSync(gemfile)) return null;
+	let lock;
+	try {
+		lock = readFileSync(lockfile, "utf-8");
+	} catch {
+		return null;
+	}
+	if (!COCOAPODS_SPEC.test(lock)) return null;
+	return {
+		gemfile,
+		lockfile
+	};
+}
+function podInstallCommand(root, ...args) {
+	const pod = [
+		"pod",
+		"install",
+		...args
+	].join(" ");
+	return bundlerPin(root) ? `bundle exec ${pod}` : pod;
+}
+const BUILD_FAILED = "** BUILD FAILED **";
+const POSITIONED = /^(\S[^\t]*?):(\d+):(?:(\d+):)?\s*(?:fatal\s+)?error:\s+(.+)$/;
+const UNPOSITIONED = /^(\S[^\t]*?)?\berror:\s+(.+)$/;
+const LD_ERROR = /^ld:\s+(?!warning:)(.+)$/;
+const UNDEFINED_HEADER = /^(?:ld:\s+)?Undefined symbols?(?:\s+for architecture\s+\S+)?:\s*$/;
+const UNDEFINED_SYMBOL = /^\s+"?([^",]+)"?,\s+referenced from:\s*$/;
+function undefinedSymbolMessage(symbol) {
+	return `Undefined symbol: ${symbol}`;
+}
+const PODS_OUT_OF_SYNC = /The sandbox is not in sync with the Podfile\.lock/;
+const SIGNING = [
+	/No profiles for '.*' were found/,
+	/requires a development team/i,
+	/[Cc]ode ?[Ss]igning [Ee]rror/,
+	/No signing certificate/i,
+	/code signing is required/i,
+	/errSecInternalComponent/,
+	/Provisioning profile .* doesn't (?:include|match)/i
+];
+const NO_SUCH_SCHEME = /does not contain a scheme named/;
+const CAS_CORRUPT = /not a IncludeTreeRoot node kind/;
+const 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, root, sdk) {
+	if (CAS_CORRUPT.test(message)) return "The compilation cache holds a damaged object. Run `stim gc --delete --cache \"compilation cache\"` to empty that cache, then build again. The next build is a cold one.";
+	if (PODS_OUT_OF_SYNC.test(message)) return `Run \`${root ? podInstallCommand(root) : "pod install"}\` in ios/ (stim ios does this when Podfile.lock and Pods/Manifest.lock disagree), then build again.`;
+	if (NO_SUCH_SCHEME.test(message)) return "Run `xcodebuild -list` in ios/ to see the schemes this project defines, and share the app scheme so it is visible to the build.";
+	for (const pattern of SIGNING) if (pattern.test(message)) return sdk.startsWith("iphoneos") ? DEVICE_SIGNING_REMEDY : SIMULATOR_SIGNING_REMEDY;
+	return null;
+}
+function fileFromPrefix(prefix) {
+	const trimmed = String(prefix).trim().replace(/:$/, "");
+	if (!trimmed) return null;
+	const head = (trimmed.split(": ")[0] ?? "").trim();
+	if (!head.includes("/")) return null;
+	return head;
+}
+function makeDiagnostic({ file = null, line = null, column = null, message }, root, sdk) {
+	const text = String(message).trim();
+	const out = { message: text };
+	if (file) out.file = file;
+	if (line !== null && line !== void 0) out.line = line;
+	if (column !== null && column !== void 0) out.column = column;
+	out.message = text;
+	const remedy = remedyFor(text, root, sdk);
+	if (remedy) out.remedy = remedy;
+	return out;
+}
+function dedupeKey(d) {
+	return `${d.file || ""}|${d.line || ""}|${d.column || ""}|${d.message}`;
+}
+function createXcodeDiagnosticCollector(root = null, sdk = "iphonesimulator") {
+	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) }, root, 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]}` }, root, 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
+			}, root, 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
+			}, root, 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 buildSettings = arch ? [
+		...cacheSettings,
+		`ARCHS=${arch}`,
+		"ONLY_ACTIVE_ARCH=YES"
+	] : cacheSettings;
+	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);
+	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
+export { tailLines as _, buildXcode as a, bundlerPin as b, detectXcodeMajorAsync as c, pickXcodeProject as d, readBundleExecutable as f, swiftPrefixMappingSupported as g, startBuildHeartbeat as h, SWIFT_PREFIX_MAPPING_MIN_SWIFT as i, parseSwiftVersion as l, resolveScheme as m, COMPILATION_CACHE_UNAVAILABLE as n, compilationCacheActivityLine as o, readBundleId as p, HEARTBEAT_INTERVAL_MS as r, compilationCacheSettings as s, COMPILATION_CACHE_NOT_RUN as t, parseXcodeMajor as u, xcodebuildArgs as v, podInstallCommand as x, describeDiagnostic as y };