stim 1.17.2 → 1.19.0

package/dist/{toolchain-DNyR3NPq.mjs → toolchain-C3xSoyUl.mjs}

@@ -1,145 +1,18 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { r as register } from "./cache-manifest-DnUHBJaU.mjs";
-import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { Z as resolveOptimizations } from "./settings-Cfd-0r2d.mjs";
-import { m as resolvePackageJson } from "./project-D47Rh0ly.mjs";
-import { _ as workspaceDerivedData, f as sharedCcache$1, p as sharedCompilationCache$1, x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
-import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
-import { o as androidHome } from "./android-B_YNZy61.mjs";
-import { t as cleanLine } from "./server-expo-CHTyXD0G.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.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-Bt8ygHE7.mjs";
+import { _ as workspaceDerivedData } from "./workspace-state-CR9X86xJ.mjs";
+import { Ot as resolveOptimizations } from "./settings-CxgngUZk.mjs";
+import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
+import { o as androidHome } from "./android-BdQC6zs1.mjs";
+import { t as cleanLine } from "./server-expo-n3tUi3Em.mjs";
 import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { stimBuildDigest } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
-import chalk from "chalk";
-const CCACHE_SLOPPINESS = "pch_defines,time_macros";
-const STATS_LOG_FILE = "ccache-stats.log";
-const CCACHE_UNAVAILABLE = {
-	status: "unavailable",
-	hits: null,
-	misses: null,
-	hitRatePercent: null
-};
-const CCACHE_NOT_RUN = {
-	status: "not-run",
-	hits: null,
-	misses: null,
-	hitRatePercent: null
-};
-function ccacheStatsLog(root) {
-	return join(workspaceLogsDir$1(root), STATS_LOG_FILE);
-}
-function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog }) {
-	return {
-		CMAKE_C_COMPILER_LAUNCHER: binary,
-		CMAKE_CXX_COMPILER_LAUNCHER: binary,
-		CCACHE_DIR: dir,
-		CCACHE_BASEDIR: workspaceRoot,
-		CCACHE_NOHASHDIR: "true",
-		CCACHE_SLOPPINESS,
-		CCACHE_MAXSIZE: "5G",
-		CCACHE_STATSLOG: statsLog
-	};
-}
-function parseCcacheBinary(output) {
-	const first = String(output ?? "").split("\n")[0]?.trim();
-	if (!first || !isAbsolute(first)) return null;
-	return first;
-}
-const CMAKE_LAUNCHER = /CMAKE_(C|CXX)_COMPILER_LAUNCHER\b/;
-function projectCmakeLauncher(source) {
-	if (typeof source !== "string") return null;
-	const match = CMAKE_LAUNCHER.exec(source);
-	return match ? `CMAKE_${match[1]}_COMPILER_LAUNCHER` : null;
-}
-const HIT_COUNTERS = /* @__PURE__ */ new Set(["direct_cache_hit", "preprocessed_cache_hit"]);
-function parseCcacheStatsLog(text) {
-	if (typeof text !== "string") return null;
-	let hits = 0;
-	let misses = 0;
-	for (const raw of text.split("\n")) {
-		const line = raw.trim();
-		if (HIT_COUNTERS.has(line)) hits += 1;
-		else if (line === "cache_miss") misses += 1;
-	}
-	const total = hits + misses;
-	if (total === 0) return null;
-	return {
-		status: "reported",
-		hits,
-		misses,
-		hitRatePercent: Math.round(hits / total * 1e3) / 10
-	};
-}
-function readCcacheActivity(statsLog) {
-	let text;
-	try {
-		text = readFileSync(statsLog, "utf-8");
-	} catch {
-		return CCACHE_UNAVAILABLE;
-	}
-	return parseCcacheStatsLog(text) ?? CCACHE_UNAVAILABLE;
-}
-function ccacheActivityLine(activity) {
-	if (activity.status === "reported") return `${activity.hits} hits / ${activity.misses} misses (${activity.hitRatePercent}%)`;
-	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
-	return "unavailable; no C++ compile went through ccache";
-}
-function lookupCcache() {
-	try {
-		return parseCcacheBinary(getExecutor().findExecutable("ccache"));
-	} catch {
-		return null;
-	}
-}
-function readOrNull(file) {
-	try {
-		return readFileSync(file, "utf-8");
-	} catch {
-		return null;
-	}
-}
-function canonical(root) {
-	try {
-		return realpathSync(root);
-	} catch {
-		return root;
-	}
-}
-function resolveCcache({ root, dir = sharedCcache$1(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
-	const binary = lookup();
-	if (!binary) {
-		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
-		return null;
-	}
-	const declared = projectCmakeLauncher(readOrNull(join(root, "android", "app", "build.gradle")));
-	if (declared) {
-		onNote(chalk.dim(phaseLine("cache", `ccache off (android/app/build.gradle sets ${declared} itself)`)));
-		return null;
-	}
-	const statsLog = ccacheStatsLog(root);
-	register({
-		dir,
-		name: "ccache",
-		prune: "atomic",
-		note: "ccache keeps itself under CCACHE_MAXSIZE, so it is emptied whole or not at all"
-	});
-	onNote(chalk.dim(phaseLine("cache", `ccache on (${dir})`)));
-	return {
-		dir,
-		statsLog,
-		env: ccacheEnvironment({
-			binary,
-			dir,
-			workspaceRoot: canonical(root),
-			statsLog
-		})
-	};
-}
-//#endregion
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
 //#region src/engine/bundler.ts
 const COCOAPODS_SPEC = /^ {4}cocoapods \(/m;
 function bundlerPin(root) {
@@ -300,15 +173,6 @@ function describeDiagnostic(diagnostic) {
 }
 //#endregion
 //#region src/engine/xcode.ts
-const IOS_DIR = "ios";
-const PREBUILD_REMEDY = "Generate it with `npx expo prebuild -p ios` (stim ios does this automatically for an Expo project with no ios/ directory), or commit the native project.";
-function buildFailure(message, remedy) {
-	return { error: {
-		code: "STIM_BUILD_FAILED",
-		message,
-		remedy
-	} };
-}
 function pickXcodeProject(entries) {
 	const names = (Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string");
 	const workspaces = names.filter((e) => e.endsWith(".xcworkspace")).toSorted();
@@ -336,22 +200,6 @@ function pickXcodeProject(entries) {
 	}
 	return null;
 }
-function discoverXcodeProject(root) {
-	const dir = join(root, IOS_DIR);
-	let entries;
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return buildFailure(`No ${IOS_DIR}/ directory in ${root}.`, PREBUILD_REMEDY);
-	}
-	const picked = pickXcodeProject(entries);
-	if (!picked) return buildFailure(`${dir} contains no .xcworkspace and no .xcodeproj.`, PREBUILD_REMEDY);
-	return {
-		...picked,
-		dir,
-		path: join(dir, picked.file)
-	};
-}
 function parseSchemeList(text) {
 	const empty = {
 		name: null,
@@ -454,18 +302,6 @@ function compilationPrefixMappings(workspaceRoot, derivedDataPath) {
 	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) mappings.push(`${derived}=/^derived-data`);
 	return mappings.map((mapping) => /[\s"\\]/.test(mapping) ? `"${mapping.replace(/["\\]/g, "\\$&")}"` : mapping).join(" ");
 }
-function ccacheEnabled(podfileProperties) {
-	if (!podfileProperties || typeof podfileProperties !== "object") return false;
-	return podfileProperties["apple.ccacheEnabled"] === "true";
-}
-function readPodfileProperties(root) {
-	try {
-		const parsed = JSON.parse(readFileSync(join(root, IOS_DIR, "Podfile.properties.json"), "utf-8"));
-		return parsed && typeof parsed === "object" ? parsed : null;
-	} catch {
-		return null;
-	}
-}
 const SWIFT_PREFIX_MAPPING_MIN_SWIFT = {
 	major: 6,
 	minor: 4
@@ -475,40 +311,12 @@ function swiftPrefixMappingSupported(version) {
 	const min = SWIFT_PREFIX_MAPPING_MIN_SWIFT;
 	return version.major > min.major || version.major === min.major && version.minor >= min.minor;
 }
-const SWIFT_CACHE_MIN_REACT_NATIVE = {
-	major: 0,
-	minor: 87
-};
-function reactNativeSupportsSwiftCache(version) {
-	if (!version) return false;
-	const min = SWIFT_CACHE_MIN_REACT_NATIVE;
-	return version.major > min.major || version.major === min.major && version.minor >= min.minor;
-}
-function parseReactNativeVersion(packageJson) {
-	if (!packageJson || typeof packageJson !== "object") return null;
-	const raw = packageJson.version;
-	const m = typeof raw === "string" ? /^(\d+)\.(\d+)\./.exec(raw) : null;
-	if (!m || m[1] === void 0 || m[2] === void 0) return null;
-	return {
-		major: parseInt(m[1], 10),
-		minor: parseInt(m[2], 10)
-	};
-}
-function detectReactNativeVersion(root) {
-	const file = resolvePackageJson(root, "react-native");
-	if (!file) return null;
-	try {
-		return parseReactNativeVersion(JSON.parse(readFileSync(file, "utf-8")));
-	} catch {
-		return null;
-	}
-}
-function compilationCacheSettings({ workspaceRoot, derivedDataPath, casPath, xcodeMajor, swiftVersion = null, reactNativeVersion = null, ccache = false, optimizations = resolveOptimizations({}, {}).ios }) {
+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 && reactNativeSupportsSwiftCache(reactNativeVersion);
+	const auto = swiftMappable && swiftCacheCompatible;
 	const swift = optimizations.compilationCache && (optimizations.swiftCompilationCache ?? auto);
 	const mappings = optimizations.prefixMapping ? compilationPrefixMappings(workspaceRoot, derivedDataPath) : "";
 	return [
@@ -544,34 +352,6 @@ function parseXcodeMajor(output) {
 function detectXcodeMajor(exec = null) {
 	return parseXcodeMajor((exec || getExecutor()).runQuiet("xcodebuild -version", { timeoutMs: 1e4 }));
 }
-function resolveCompilationCacheSettings({ root, derivedDataPath, exec = null, casPath = sharedCompilationCache$1(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
-	const xcodeMajor = detectXcodeMajor(exec);
-	const ccache = ccacheEnabled(readPodfileProperties(root));
-	const probe = xcodeMajor !== null && xcodeMajor >= 26 && !ccache && optimizations.compilationCache && optimizations.swiftCompilationCache !== false;
-	const swiftVersion = probe ? detectSwiftVersion(exec) : null;
-	const reactNativeVersion = probe ? detectReactNativeVersion(root) : null;
-	const settings = compilationCacheSettings({
-		workspaceRoot: root,
-		derivedDataPath,
-		casPath,
-		xcodeMajor,
-		swiftVersion,
-		reactNativeVersion,
-		ccache,
-		optimizations
-	});
-	if (settings.length > 0 && optimizations.compilationCache) {
-		register({
-			dir: casPath,
-			name: "Xcode compilation cache",
-			prune: "atomic",
-			note: "shared Xcode compilation cache"
-		});
-		const swift = settings.includes("SWIFT_ENABLE_COMPILE_CACHE=YES") ? settings.includes("SWIFT_ENABLE_PREFIX_MAPPING=YES") ? "Swift on" : "Swift on, unmapped" : swiftVersion && !swiftPrefixMappingSupported(swiftVersion) ? `Swift off, ${swiftVersion.major}.${swiftVersion.minor} < ${SWIFT_PREFIX_MAPPING_MIN_SWIFT.major}.${SWIFT_PREFIX_MAPPING_MIN_SWIFT.minor}` : swiftVersion && reactNativeVersion && !reactNativeSupportsSwiftCache(reactNativeVersion) ? `Swift off, react-native ${reactNativeVersion.major}.${reactNativeVersion.minor} < ${SWIFT_CACHE_MIN_REACT_NATIVE.major}.${SWIFT_CACHE_MIN_REACT_NATIVE.minor}` : "Swift off";
-		onNote(chalk.dim(phaseLine("cache", `compilation cache on (CAS at ${casPath}, ${swift})`)));
-	}
-	return settings;
-}
 function xcodebuildArgs({ project, scheme, udid = null, destination = null, configuration = "Debug", sdk = "iphonesimulator", derivedDataPath, extraArgs = [], buildSettings = [] }) {
 	return [
 		project.flag,
@@ -774,13 +554,13 @@ function compilationCacheActivityLine(activity) {
 	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
 	return "unavailable; Xcode did not report reliable statistics";
 }
-async function buildIos({ root, udid = null, logWriter, project = null, scheme = null, configuration = "Debug", sdk = "iphonesimulator", destination = null, arch = null, derivedDataPath = null, extraArgs = [], compilationCache = void 0, optimizations = resolveOptimizations({}, {}).ios, now = () => Date.now(), exec = null, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), onNote = (line) => console.error(line) }) {
-	if (!root || typeof root !== "string") throw new TypeError("buildIos requires {root}");
-	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildIos requires {logWriter} with a write() method");
-	if (!udid && !destination) throw new TypeError("buildIos requires {udid} (or an explicit {destination})");
+async function buildXcode({ root, udid = null, logWriter, project, scheme = null, configuration = "Debug", 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 = now();
+	const startedAt = clockStart ?? now();
 	const elapsed = () => now() - startedAt;
 	const reportError = (message, remedy) => {
 		logWriter.write({
@@ -791,23 +571,18 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 			...remedy ? { remedy } : {}
 		});
 	};
-	let target = project;
-	if (!target) {
-		const discovered = discoverXcodeProject(root);
-		if (discovered.error) {
-			reportError(discovered.error.message, discovered.error.remedy);
-			return failedResult({
-				code: discovered.error.code,
-				diagnostics: [{
-					message: discovered.error.message,
-					remedy: discovered.error.remedy ?? void 0
-				}],
-				durationMs: elapsed()
-			});
-		}
-		target = discovered;
+	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 = target;
+	const resolvedTarget = project;
 	const selected = resolveScheme(resolvedTarget, {
 		exec: executor,
 		scheme
@@ -824,12 +599,9 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 		});
 	}
 	const buildScheme = selected.scheme;
-	const cacheSettings = compilationCache === void 0 ? resolveCompilationCacheSettings({
-		root,
+	const cacheSettings = typeof compilationCache === "function" ? compilationCache({
 		derivedDataPath: dd,
-		exec: executor,
-		onNote,
-		optimizations
+		exec: executor
 	}) : compilationCache || [];
 	const buildSettings = arch ? [
 		...cacheSettings,
@@ -1075,11 +847,436 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 	};
 }
 //#endregion
-//#region src/offload/manifest.ts
-function manifestDigest(entries) {
-	const hash = createHash("sha256");
-	for (const entry of entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) hash.update(`${entry.path}\0${entry.kind}\0${entry.sha256}\n`);
-	return hash.digest("hex");
+//#region src/engine/deps.ts
+const DEPS_ERROR = "STIM_DEPS_FAILED";
+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) {
+	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: "ios/Podfile.lock is missing but ios/Pods exists"
+	};
+	if (manifest === null) return {
+		stale: true,
+		reason: "ios/Pods/Manifest.lock is missing (pods have never been installed here)"
+	};
+	if (lock !== manifest) return {
+		stale: true,
+		reason: "ios/Podfile.lock and ios/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 podfilePath(root) {
+	return join(root, "ios", "Podfile");
+}
+function readPodState(root) {
+	return {
+		hasPodfile: existsSync(podfilePath(root)),
+		lockText: readOrNull(join(root, "ios", "Podfile.lock")),
+		manifestText: readOrNull(join(root, "ios", "Pods", "Manifest.lock"))
+	};
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function podEnv(root, options = {}) {
+	return podEnvForRuby(readRubyVersion(root), options);
+}
+function podEnvForRuby(version, { env = process.env, home = homedir(), exists = existsSync } = {}) {
+	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"
+	};
+	if (!version) return out;
+	const candidates = [
+		{ bin: join(home, ".rbenv", "versions", version, "bin") },
+		{
+			bin: join(home, ".rvm", "rubies", `ruby-${version}`, "bin"),
+			gems: join(home, ".rvm", "gems", `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;
+		out.PATH = `${c.bin}${delimiter}${out.PATH ?? ""}`;
+		if (c.gems && exists(c.gems)) {
+			out.GEM_HOME = c.gems;
+			out.GEM_PATH = c.gems;
+		}
+		break;
+	}
+	return out;
+}
+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;
+	}
+}
+function bundlerEnv(root, gemfile) {
+	return {
+		...podEnv(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(() => 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 = 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(root, 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(root, 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 ${root} && 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 ${root} && bundle install\` and fix what it reports, then run again.`;
+}
+async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line) } = {}) {
+	const iosDir = join(root, "ios");
+	if (!existsSync(iosDir)) return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: `No ios/ 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);
+	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 run = await runCaptured({
+		...ctx,
+		cmd: args[0],
+		args: args.slice(1),
+		cwd: iosDir,
+		env: bundler && pin ? bundlerEnv(root, pin.gemfile) : podEnv(root),
+		event: "pod_install",
+		label: "pods",
+		estimateMs
+	});
+	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(root, 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 ${root} && 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: []
+	};
+}
+function missingPod(err) {
+	if (!isMissingBinary(err)) return null;
+	return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: "CocoaPods is not installed: no `pod` executable on PATH.",
+		remedy: "Install CocoaPods (`brew install cocoapods`, or `gem install cocoapods`) and run again.",
+		lastLines: []
+	};
 }
 //#endregion
 //#region src/offload/toolchain.ts
@@ -1087,7 +1284,10 @@ const distDir = dirname(fileURLToPath(import.meta.url));
 function quiet(file, args) {
 	return getExecutor().runFileQuiet(file, args, { timeoutMs: 2e4 });
 }
-function iosToolchain() {
+function iosToolchain(root) {
+	return iosToolchainForRuby(readRubyVersion(root));
+}
+function iosToolchainForRuby(rubyVersion) {
 	const xcode = quiet("xcodebuild", ["-version"]);
 	return {
 		stimBuild: stimBuildDigest(distDir),
@@ -1098,9 +1298,15 @@ function iosToolchain() {
 			"iphonesimulator",
 			"--show-sdk-version"
 		])?.trim() ?? null,
-		cocoapods: quiet("pod", ["--version"])?.trim().split("\n").pop()?.trim() ?? null
+		cocoapods: cocoapodsVersion(rubyVersion)
 	};
 }
+function cocoapodsVersion(rubyVersion) {
+	return getExecutor().runFileQuiet("pod", ["--version"], {
+		timeoutMs: 2e4,
+		env: Object.fromEntries(Object.entries(podEnvForRuby(rubyVersion)).filter((entry) => entry[1] !== void 0))
+	})?.trim().split("\n").pop()?.trim() ?? null;
+}
 function macosToolchain() {
 	const xcode = quiet("xcodebuild", ["-version"]);
 	return {
@@ -1190,7 +1396,7 @@ function sdkPackages() {
 		platforms
 	};
 }
-function workerToolchain() {
+function workerToolchain(rubyVersion = null) {
 	let listed = null;
 	try {
 		listed = JSON.parse(quiet("xcrun", [
@@ -1202,7 +1408,7 @@ function workerToolchain() {
 		]) ?? "null");
 	} catch {}
 	return {
-		...iosToolchain(),
+		...iosToolchainForRuby(rubyVersion),
 		macosSdk: quiet("xcrun", [
 			"--sdk",
 			"macosx",
@@ -1295,4 +1501,4 @@ function toolchainMismatches(target, worker) {
 	return out;
 }
 //#endregion
-export { podInstallCommand as C, projectCmakeLauncher as D, ccacheActivityLine as E, readCcacheActivity as O, bundlerPin as S, CCACHE_UNAVAILABLE as T, readBundleId as _, toolchainMismatches as a, tailLines as b, COMPILATION_CACHE_NOT_RUN as c, buildIos as d, ccacheEnabled as f, readBundleExecutable as g, discoverXcodeProject as h, macosToolchain as i, resolveCcache as k, COMPILATION_CACHE_UNAVAILABLE as l, detectXcodeMajor as m, androidToolchain as n, workerToolchain as o, compilationCacheActivityLine as p, iosToolchain as r, manifestDigest as s, androidRequirements as t, HEARTBEAT_INTERVAL_MS as u, resolveScheme as v, CCACHE_NOT_RUN as w, describeDiagnostic as x, startBuildHeartbeat as y };
+export { bundlerPin as A, readBundleExecutable as C, swiftPrefixMappingSupported as D, startBuildHeartbeat as E, tailLines as O, pickXcodeProject as S, resolveScheme as T, buildXcode as _, toolchainMismatches as a, detectSwiftVersion as b, podsAreStale as c, runCaptured as d, runPodInstall as f, SWIFT_PREFIX_MAPPING_MIN_SWIFT as g, HEARTBEAT_INTERVAL_MS as h, macosToolchain as i, podInstallCommand as j, describeDiagnostic as k, readPodState as l, COMPILATION_CACHE_UNAVAILABLE as m, androidToolchain as n, workerToolchain as o, COMPILATION_CACHE_NOT_RUN as p, iosToolchain as r, DEPS_ERROR as s, androidRequirements as t, readRubyVersion as u, compilationCacheActivityLine as v, readBundleId as w, detectXcodeMajor as x, compilationCacheSettings as y };