stim 1.20.2 → 1.22.0

package/dist/toolchain-DpJMHq0n.mjs

@@ -0,0 +1,876 @@
+import { d as spawnDeclared, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as killOnAbort } from "./operation-exec-BW0em61G.mjs";
+import { o as androidHome } from "./android-C7sVmyI9.mjs";
+import { b as bundlerPin, h as startBuildHeartbeat, r as HEARTBEAT_INTERVAL_MS } from "./xcode-BXn9-xYx.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, dirname, isAbsolute, join, 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";
+//#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, 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"),
+			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;
+		}
+		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;
+}
+/**
+* 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"))) {
+		const gems = join(rvm, "gems", alias);
+		const global = `${gems}@global`;
+		return {
+			bins: [
+				join(gems, "bin"),
+				join(global, "bin"),
+				join(rvm, "rubies", alias, "bin")
+			].filter(exists),
+			gems: {
+				home: gems,
+				path: [gems, global].join(delimiter)
+			}
+		};
+	}
+	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(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), 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);
+	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 ? await bundlerEnv(root, pin.gemfile) : await podEnvForRubyAsync(readRubyVersion(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
+const distDir = dirname(fileURLToPath(import.meta.url));
+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;
+	}
+}
+async function iosToolchainAsync(root, native) {
+	const rubyVersion = native ? null : readRubyVersion(root);
+	const [xcode, simulatorSdk, cocoapods] = await Promise.all([
+		quietAsync("xcodebuild", ["-version"]),
+		quietAsync("xcrun", [
+			"--sdk",
+			"iphonesimulator",
+			"--show-sdk-version"
+		]),
+		native ? null : cocoapodsVersionAsync(rubyVersion)
+	]);
+	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),
+		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 cocoapodsVersionAsync(rubyVersion) {
+	try {
+		return podVersionLine(await getExecutor().runFileAsync("pod", ["--version"], {
+			timeoutMs: 2e4,
+			env: podProbeEnv(await podEnvForRubyAsync(rubyVersion))
+		}));
+	} 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),
+		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"` gives it. */
+function jdkMajor(release) {
+	return /^JAVA_VERSION="(\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;
+}
+function androidToolchain() {
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		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),
+		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 androidRequirements(projectRoot) {
+	try {
+		const pkg = createRequire(join(projectRoot, "package.json")).resolve("react-native/package.json");
+		return parseAndroidRequirements(readFileSync(join(dirname(pkg), "gradle", "libs.versions.toml"), "utf8"));
+	} catch {
+		return {
+			ndk: null,
+			buildTools: null,
+			compileSdk: null
+		};
+	}
+}
+/** 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
+	};
+}
+function workerToolchain(rubyVersion = null, native) {
+	if (native === "gradle") return {
+		...androidToolchain(),
+		os: process.platform,
+		xcode: null,
+		simulatorSdk: null,
+		cocoapods: null,
+		macosSdk: null,
+		bundler: null,
+		runtimes: [],
+		androidSdk: sdkPackages()
+	};
+	let listed = null;
+	try {
+		listed = JSON.parse(quiet("xcrun", [
+			"simctl",
+			"list",
+			"devices",
+			"available",
+			"-j"
+		]) ?? "null");
+	} catch {}
+	return {
+		...iosToolchainForRuby(rubyVersion, native),
+		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(),
+		androidSdk: native ? null : sdkPackages()
+	};
+}
+/** 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 androidMismatches(local, requires, worker) {
+	const out = [];
+	if (!local.jdk || worker.jdk !== local.jdk) out.push({
+		code: "jdk",
+		reason: `JDK ${worker.jdk ?? "none"} there, ${local.jdk ?? "none"} here`
+	});
+	const sdk = worker.androidSdk;
+	if (!sdk) return [...out, {
+		code: "android-sdk",
+		reason: "no Android SDK there"
+	}];
+	if (requires.ndk && !sdk.ndk.includes(requires.ndk)) out.push({
+		code: "ndk",
+		reason: `no NDK ${requires.ndk} there`
+	});
+	if (requires.buildTools && !sdk.buildTools.includes(requires.buildTools)) out.push({
+		code: "build-tools",
+		reason: `no build-tools ${requires.buildTools} there`
+	});
+	if (requires.compileSdk && !sdk.platforms.some((dir) => platformLevel(dir) === requires.compileSdk)) out.push({
+		code: "compile-sdk",
+		reason: `no platform android-${requires.compileSdk} there`
+	});
+	return out;
+}
+function versionMismatch(tool, there, here) {
+	const side = (version) => version ? version.startsWith(tool) ? version : `${tool} ${version}` : `no ${tool}`;
+	return `${side(there)} there, ${side(here)} here`;
+}
+/** 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.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 (worker.arch !== local.arch) out.push({
+		code: "arch",
+		reason: `CPU ${worker.arch} there, ${local.arch} here`
+	});
+	if (target.platform === "macos") {
+		const macos = target.local;
+		if (!macos.xcode || worker.xcode !== macos.xcode) out.push({
+			code: "xcode",
+			reason: versionMismatch("Xcode", worker.xcode, macos.xcode)
+		});
+		if (!macos.macosSdk || worker.macosSdk !== macos.macosSdk) out.push({
+			code: "macos-sdk",
+			reason: versionMismatch("macOS SDK", worker.macosSdk, macos.macosSdk)
+		});
+		return out;
+	}
+	const ios = target.local;
+	if (!ios.xcode || worker.xcode !== ios.xcode) out.push({
+		code: "xcode",
+		reason: versionMismatch("Xcode", worker.xcode, ios.xcode)
+	});
+	if (!ios.simulatorSdk || worker.simulatorSdk !== ios.simulatorSdk) out.push({
+		code: "simulator-sdk",
+		reason: versionMismatch("simulator SDK", worker.simulatorSdk, ios.simulatorSdk)
+	});
+	if (!target.native && target.cocoapodsPinned) {
+		if (!worker.bundler) out.push({
+			code: "bundler",
+			reason: "no Bundler there to run the CocoaPods this project's Gemfile.lock pins"
+		});
+	} else if (!target.native && worker.cocoapods !== ios.cocoapods) out.push({
+		code: "cocoapods",
+		reason: versionMismatch("CocoaPods", worker.cocoapods, ios.cocoapods)
+	});
+	if (target.runtime && !worker.runtimes.includes(target.runtime)) out.push({
+		code: "runtime",
+		reason: `no iPhone simulator on ${target.runtime} there`
+	});
+	return out;
+}
+//#endregion
+export { runCaptured as _, iosToolchainAsync as a, macosToolchain as c, toolchainMismatches as d, workerToolchain as f, readRubyVersion as g, readPodState as h, availableIphone as i, macosToolchainAsync as l, podsAreStale as m, androidToolchain as n, iphoneRuntimes as o, DEPS_ERROR as p, androidToolchainAsync as r, jdkMajor as s, androidRequirements as t, parseAndroidRequirements as u, runPodInstall as v };