stim 0.0.0 → 1.1.0

package/dist/android-cas-DGlTStWu.mjs

@@ -0,0 +1,1078 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { k as withDirLock, u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { r as register } from "./cache-manifest-oeH18ERr.mjs";
+import { D as workspaceLogsDir, x as sharedCcache, y as ensureWorkspaceStorage } from "./state-IYEY-zi8.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { l as phaseLine } from "./command-output-8wHMEde0.mjs";
+import { n as androidHome } from "./android-xmyGBNy5.mjs";
+import { f as startBuildHeartbeat, r as HEARTBEAT_INTERVAL_MS } from "./xcode-CDB6fytw.mjs";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+const MAX_MESSAGE_LENGTH = 300;
+const KOTLIN_URI = /^e:\s+file:\/\/(\/\S+?):(\d+):(\d+)\s+(.*)$/;
+const KOTLIN_PAREN = /^e:\s+(\S+?):\s*\((\d+),\s*(\d+)\):\s*(.*)$/;
+const KOTLIN_BARE = /^e:\s+(.*)$/;
+const FILE_LINE_ERROR = /^([^\s:]+):(\d+):(?:(\d+):)?\s*(?:AAPT:\s*)?error:\s*(.*)$/i;
+const AAPT_PREFIXED = /^ERROR:\s*([^\s:]+):(\d+):(?:(\d+):)?\s*(.*)$/;
+const BARE_ERROR = /^error:\s*(.*)$/i;
+const FATAL_ERROR = /FATAL_ERROR/;
+const TASK_FAILED = /^>\s*Task\s+(:[A-Za-z0-9_.:-]+)\s+FAILED\b/;
+const FAILURE_HEADER = /^FAILURE:\s*Build (?:failed|completed with)/;
+const WHAT_WENT_WRONG = /^\*\s*What went wrong:/;
+const SECTION = /^\*\s*[A-Za-z]/;
+const COULD_NOT_RESOLVE = /^>?\s*(Could not (?:resolve|find|download|GET) .+)$/;
+const EXECUTION_FAILED = /^Execution failed for task\s+'(?::[^']+)'/;
+const CAUSE_LINE = /^>\s+\S/;
+const JAVA_EXCEPTION = /^(?:[a-z][A-Za-z0-9_]*\.){2,}[A-Za-z0-9_$]*(?:Exception|Error)\b/;
+const TASK_LINE = /^>\s*Task\s+:/;
+const BUILD_TAIL = /^(?:BUILD (?:FAILED|SUCCESSFUL) in\b|Deprecated Gradle features were used\b|You can use '--warning-mode|For more on this, please refer to\b|\d+ actionable task|Configuration cache entry\b)/;
+const MAX_CAUSE_LINES = 6;
+const REMEDIES = [
+	[/JAVA_HOME is (?:set to an invalid directory|not set)/i, "Point JAVA_HOME at a JDK 17 install (`export JAVA_HOME=$(/usr/libexec/java_home -v 17)`) and run again."],
+	[/SDK location not found|ANDROID_HOME|ANDROID_SDK_ROOT|sdk\.dir/i, "Set ANDROID_HOME to the Android SDK (usually ~/Library/Android/sdk), or write sdk.dir into android/local.properties."],
+	[/licen[cs]es? (?:have not been|has not been) accepted|You have not accepted the license/i, "Accept the SDK licences: `$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses`."],
+	[/Failed to install the following (?:Android )?SDK packages|package is not installed/i, "Install the missing SDK package with `$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager \"<package>\"`."],
+	[/Unsupported class file major version|invalid source release|compiled by a more recent version of the Java|Could not determine java version/i, "The JDK does not match what this project builds with; select JDK 17 (`export JAVA_HOME=$(/usr/libexec/java_home -v 17)`)."],
+	[/Could not (?:resolve|find|download|GET)/i, "Check network access and the repositories block. After a bad cache entry, `./gradlew --refresh-dependencies assembleDebug` in android/ re-resolves."],
+	[/Android resource linking failed|AAPT/i, "Fix the resource file and line named above (under android/app/src/main/res); aapt2 reports the exact element it could not link."]
+];
+function remedyFor(message) {
+	const text = String(message || "");
+	for (const [pattern, remedy] of REMEDIES) if (pattern.test(text)) return remedy;
+	return null;
+}
+function extractGradleDiagnostics(text) {
+	if (typeof text !== "string" || text.trim() === "") return [];
+	const lines = text.split("\n");
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (diag) => {
+		const message = clip(diag.message);
+		if (!message) return;
+		const key = `${diag.file || ""}|${diag.line ?? ""}|${message}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		const record = { message };
+		if (diag.file) record.file = diag.file;
+		if (diag.line != null) record.line = diag.line;
+		if (diag.column != null) record.column = diag.column;
+		const remedy = remedyFor(`${diag.file || ""} ${message}`);
+		if (remedy) record.remedy = remedy;
+		found.push(record);
+	};
+	for (let i = 0; i < lines.length; i++) {
+		const line = stripCarriage(lines[i]).trim();
+		if (!line) continue;
+		if (FAILURE_HEADER.test(line)) {
+			const block = readWhatWentWrong(lines, i);
+			if (block) {
+				add({ message: block.message });
+				for (const highlight of block.highlights) add({ message: highlight });
+				i = block.endIndex;
+			}
+			continue;
+		}
+		if (WHAT_WENT_WRONG.test(line)) {
+			const block = readWhatWentWrong(lines, i - 1);
+			if (block) {
+				add({ message: block.message });
+				for (const highlight of block.highlights) add({ message: highlight });
+				i = block.endIndex;
+			}
+			continue;
+		}
+		if (EXECUTION_FAILED.test(line)) {
+			const chain = readCauseChain(lines, i);
+			add({ message: chain.message });
+			for (const highlight of chain.highlights) add({ message: highlight });
+			i = chain.endIndex;
+			continue;
+		}
+		if (FATAL_ERROR.test(line)) {
+			add({ message: line });
+			continue;
+		}
+		const orphanCause = CAUSE_LINE.test(line) ? line.replace(/^>\s*/, "") : "";
+		if (JAVA_EXCEPTION.test(orphanCause)) {
+			add({ message: orphanCause });
+			continue;
+		}
+		const kotlinUri = KOTLIN_URI.exec(line);
+		if (kotlinUri) {
+			const uriFile = kotlinUri[1];
+			const uriMsg = kotlinUri[4];
+			if (uriFile === void 0 || uriMsg === void 0) continue;
+			add({
+				file: decodePath(uriFile),
+				line: Number(kotlinUri[2]),
+				column: Number(kotlinUri[3]),
+				message: uriMsg
+			});
+			continue;
+		}
+		const kotlinParen = KOTLIN_PAREN.exec(line);
+		if (kotlinParen) {
+			const parenMsg = kotlinParen[4];
+			if (parenMsg === void 0) continue;
+			add({
+				file: kotlinParen[1],
+				line: Number(kotlinParen[2]),
+				column: Number(kotlinParen[3]),
+				message: parenMsg
+			});
+			continue;
+		}
+		const aapt = AAPT_PREFIXED.exec(line);
+		if (aapt) {
+			const aaptMsg = aapt[4];
+			if (aaptMsg === void 0) continue;
+			add({
+				file: aapt[1],
+				line: Number(aapt[2]),
+				column: aapt[3] ? Number(aapt[3]) : void 0,
+				message: stripAaptPrefix(aaptMsg)
+			});
+			continue;
+		}
+		const fileError = FILE_LINE_ERROR.exec(line);
+		if (fileError) {
+			const errMsg = fileError[4];
+			if (errMsg === void 0) continue;
+			add({
+				file: fileError[1],
+				line: Number(fileError[2]),
+				column: fileError[3] ? Number(fileError[3]) : void 0,
+				message: errMsg
+			});
+			continue;
+		}
+		const kotlinBare = KOTLIN_BARE.exec(line);
+		if (kotlinBare) {
+			const bareMsg = kotlinBare[1];
+			if (bareMsg === void 0) continue;
+			add({ message: bareMsg });
+			continue;
+		}
+		const bare = BARE_ERROR.exec(line);
+		if (bare) {
+			const bareErrMsg = bare[1];
+			if (bareErrMsg === void 0) continue;
+			add({ message: bareErrMsg });
+			continue;
+		}
+		const resolve = COULD_NOT_RESOLVE.exec(line);
+		if (resolve) {
+			const resolveMsg = resolve[1];
+			if (resolveMsg === void 0) continue;
+			add({ message: resolveMsg });
+			continue;
+		}
+		const task = TASK_FAILED.exec(line);
+		if (task) {
+			add({ message: `Task ${task[1]} FAILED` });
+			continue;
+		}
+	}
+	return found;
+}
+function capDiagnostics(diagnostics, limit = 10) {
+	const all = Array.isArray(diagnostics) ? diagnostics : [];
+	if (all.length <= limit) return {
+		shown: all.slice(),
+		truncated: 0
+	};
+	return {
+		shown: all.slice(0, limit),
+		truncated: all.length - limit
+	};
+}
+function formatDiagnostic(diag) {
+	if (!diag) return "";
+	return `${diag.file ? `${diag.file}${diag.line != null ? `:${diag.line}` : ""}${diag.line != null && diag.column != null ? `:${diag.column}` : ""}: ` : ""}${diag.message}`;
+}
+function readWhatWentWrong(lines, start) {
+	let i = start + 1;
+	while (i < lines.length && !WHAT_WENT_WRONG.test(stripCarriage(lines[i]).trim())) {
+		const probe = stripCarriage(lines[i]).trim();
+		if (probe !== "" && !FAILURE_HEADER.test(probe)) return null;
+		i++;
+	}
+	if (i >= lines.length) return null;
+	const parts = [];
+	let j = i + 1;
+	for (; j < lines.length; j++) {
+		const line = stripCarriage(lines[j]).trim();
+		if (SECTION.test(line)) break;
+		if (TASK_LINE.test(line)) break;
+		if (BUILD_TAIL.test(line)) continue;
+		if (line === "") {
+			if (parts.length) break;
+			continue;
+		}
+		parts.push(line.replace(/^>\s*/, ""));
+	}
+	if (parts.length === 0) return null;
+	return {
+		message: parts.join(" "),
+		highlights: highlightsOf(parts),
+		endIndex: j - 1
+	};
+}
+function readCauseChain(lines, start) {
+	const parts = [stripCarriage(lines[start]).trim()];
+	let end = start;
+	for (let j = start + 1; j < lines.length && parts.length < MAX_CAUSE_LINES; j++) {
+		const line = stripCarriage(lines[j]).trim();
+		if (!CAUSE_LINE.test(line) || TASK_LINE.test(line)) break;
+		parts.push(line.replace(/^>\s*/, ""));
+		end = j;
+	}
+	return {
+		message: parts.join(" "),
+		highlights: highlightsOf(parts),
+		endIndex: end
+	};
+}
+function highlightsOf(parts) {
+	const joined = clip(parts.join(" "));
+	return parts.filter((part) => (FATAL_ERROR.test(part) || JAVA_EXCEPTION.test(part)) && !joined.includes(clip(part)));
+}
+function stripAaptPrefix(message) {
+	return String(message).replace(/^AAPT:\s*/, "").replace(/^error:\s*/i, "");
+}
+function decodePath(path) {
+	try {
+		return decodeURIComponent(path);
+	} catch {
+		return path;
+	}
+}
+function stripCarriage(line) {
+	const text = String(line ?? "");
+	const idx = text.lastIndexOf("\r");
+	return idx === -1 ? text : text.slice(idx + 1);
+}
+function clip(message) {
+	const text = String(message ?? "").trim();
+	if (text.length <= MAX_MESSAGE_LENGTH) return text;
+	return `${text.slice(0, 297)}...`;
+}
+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(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().runQuiet("command -v ccache", { timeoutMs: 5e3 }));
+	} catch {
+		return null;
+	}
+}
+function readOrNull$1(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(), 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$1(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
+//#region src/engine/gradle.ts
+const BUILD_ERROR = "STIM_BUILD_FAILED";
+const ASSEMBLE_TASK = "assembleDebug";
+function assembleTaskFor(variant) {
+	const name = typeof variant === "string" ? variant.trim() : "";
+	if (!name) return ASSEMBLE_TASK;
+	return `assemble${name[0].toUpperCase()}${name.slice(1)}`;
+}
+const LAST_LINES = 20;
+const TRANSCRIPT_LINES = 2e3;
+function androidDir(root) {
+	return join(root, "android");
+}
+function gradlewPath(root) {
+	return join(androidDir(root), "gradlew");
+}
+function apkOutputsDir(root) {
+	return join(androidDir(root), "app", "build", "outputs", "apk");
+}
+function debugApkDir(root) {
+	return join(apkOutputsDir(root), "debug");
+}
+function discoverAndroidProject(root) {
+	const dir = androidDir(root);
+	if (!existsSync(dir)) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `No android/ directory in ${root}.`,
+		remedy: "Generate it (`npx expo prebuild -p android`, which `stim android` runs itself on an Expo project) or check out the native sources."
+	};
+	const gradlew = gradlewPath(root);
+	if (!existsSync(gradlew)) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `${gradlew} does not exist, so there is no gradle wrapper to build with.`,
+		remedy: "Restore the wrapper (`gradle wrapper` in android/, or regenerate the project with `npx expo prebuild -p android --clean`)."
+	};
+	return {
+		androidDir: dir,
+		gradlew
+	};
+}
+function androidSdkRefusal({ sdkPath, sdkExists, hasLocalProperties }) {
+	if (sdkExists || hasLocalProperties) return null;
+	return {
+		code: BUILD_ERROR,
+		reason: `No Android SDK at ${sdkPath}.`,
+		remedy: "Set ANDROID_HOME to the Android SDK (Android Studio installs it at ~/Library/Android/sdk), or write sdk.dir into android/local.properties. JAVA_HOME must point at a JDK 17 install as well."
+	};
+}
+function pickDebugApk(files) {
+	const list = (Array.isArray(files) ? files : []).filter((f) => typeof f === "string" && f.endsWith(".apk")).filter((f) => !/-(?:unsigned|unaligned)\.apk$/.test(f));
+	if (list.length === 0) return null;
+	const named = list.find((f) => baseName(f) === "app-debug.apk");
+	if (named) return named;
+	const debug = list.filter((f) => baseName(f).endsWith("-debug.apk"));
+	return (debug.length ? debug : list).toSorted((a, b) => baseName(a).length - baseName(b).length || baseName(a).localeCompare(baseName(b)))[0];
+}
+function parseOutputMetadata(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(String(text));
+	} catch {
+		return null;
+	}
+	return pickDebugApk((Array.isArray(parsed?.elements) ? parsed.elements : []).map((e) => e?.outputFile).filter((f) => typeof f === "string"));
+}
+const TRANSCRIPT_APK = [/(?:Wrote APK to|APK (?:written|generated|copied) (?:to|at)|Built the following APKs?:)\s*(\S+\.apk)/i, /Installing APK '([^']+\.apk)'/i];
+function parseApkFromTranscript(text) {
+	if (typeof text !== "string") return null;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		for (const pattern of TRANSCRIPT_APK) {
+			const m = pattern.exec(line);
+			if (m) return m[1];
+		}
+	}
+	return null;
+}
+function variantNameOf(segments) {
+	return (Array.isArray(segments) ? segments : []).filter((s) => typeof s === "string" && s.trim()).map((s, i) => i === 0 ? s : `${s[0].toUpperCase()}${s.slice(1)}`).join("");
+}
+function apkInDir(dir) {
+	const metadata = readOrNull(join(dir, "output-metadata.json"));
+	if (metadata) {
+		const named = parseOutputMetadata(metadata);
+		if (named) {
+			const abs = named.startsWith("/") ? named : join(dir, named);
+			if (existsSync(abs)) return abs;
+		}
+	}
+	const listed = pickDebugApk(safeList(dir));
+	return listed ? join(dir, listed) : null;
+}
+function listApkSubdirs(base, prefix = [], depth = 0) {
+	if (depth > 3) return [];
+	const dirs = [];
+	for (const name of safeList(base)) {
+		const path = join(base, name);
+		let isDir = false;
+		try {
+			isDir = statSync(path).isDirectory();
+		} catch {
+			continue;
+		}
+		if (!isDir) continue;
+		const rel = [...prefix, name];
+		dirs.push(rel);
+		dirs.push(...listApkSubdirs(path, rel, depth + 1));
+	}
+	return dirs;
+}
+function findVariantApkDir(root, variant) {
+	const base = apkOutputsDir(root);
+	const wanted = variant.trim().toLowerCase();
+	for (const segments of listApkSubdirs(base)) if (variantNameOf(segments).toLowerCase() === wanted) return join(base, ...segments);
+	return null;
+}
+function findDebugApksUnder(base) {
+	const found = [];
+	for (const segments of [[], ...listApkSubdirs(base)]) {
+		const dir = join(base, ...segments);
+		for (const name of safeList(dir)) {
+			if (!name.endsWith("-debug.apk")) continue;
+			if (/-(?:unsigned|unaligned)\.apk$/.test(name)) continue;
+			found.push(join(dir, name));
+		}
+	}
+	return found.toSorted();
+}
+function locateApk(root, transcript = "", variant = null) {
+	const fromTranscript = parseApkFromTranscript(transcript);
+	if (fromTranscript) {
+		const abs = fromTranscript.startsWith("/") ? fromTranscript : join(androidDir(root), fromTranscript);
+		if (existsSync(abs)) return { apkPath: abs };
+	}
+	if (variant) {
+		const dir = findVariantApkDir(root, variant);
+		return { apkPath: dir ? apkInDir(dir) : null };
+	}
+	const direct = apkInDir(debugApkDir(root));
+	if (direct) return { apkPath: direct };
+	const found = findDebugApksUnder(apkOutputsDir(root));
+	if (found.length === 1) {
+		const apk = found[0];
+		const suggested = variantNameOf(relative(apkOutputsDir(root), apk).split("/").slice(0, -1));
+		return {
+			apkPath: apk,
+			note: `no APK in ${relative(androidDir(root), debugApkDir(root))}; using ${relative(androidDir(root), apk)}${suggested ? ` -- set the android.variant setting to "${suggested}" to build this variant explicitly` : ""}`
+		};
+	}
+	if (found.length > 1) return {
+		apkPath: null,
+		candidates: found
+	};
+	return { apkPath: null };
+}
+const UNKNOWN_FLAVORS = {
+	known: false,
+	dimensions: []
+};
+function stripGroovyComments(text) {
+	let out = "";
+	let quote = "";
+	let i = 0;
+	while (i < text.length) {
+		const ch = text[i];
+		const next = text[i + 1];
+		if (quote) {
+			out += ch;
+			if (ch === "\\") {
+				out += next ?? "";
+				i += 2;
+				continue;
+			}
+			if (ch === quote) quote = "";
+			i += 1;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			out += ch;
+			i += 1;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			while (i < text.length && text[i] !== "\n") i += 1;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			i += 2;
+			while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+			i += 2;
+			out += " ";
+			continue;
+		}
+		out += ch;
+		i += 1;
+	}
+	return out;
+}
+function closingBrace(text, open) {
+	let depth = 1;
+	let quote = "";
+	for (let i = open; i < text.length; i += 1) {
+		const ch = text[i];
+		if (quote) {
+			if (ch === "\\") i += 1;
+			else if (ch === quote) quote = "";
+			continue;
+		}
+		if (ch === "\"" || ch === "'") quote = ch;
+		else if (ch === "{") depth += 1;
+		else if (ch === "}") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+function productFlavorsBody(text) {
+	const match = /(?:^|[^\w.])productFlavors\s*\{/.exec(text);
+	if (!match) return null;
+	const open = match.index + match[0].length;
+	const close = closingBrace(text, open);
+	return close < 0 ? null : text.slice(open, close);
+}
+function parseFlavorBlocks(body) {
+	const entry = /([A-Za-z_][A-Za-z0-9_]*)\s*\{/y;
+	const blocks = [];
+	let i = 0;
+	while (i < body.length) {
+		if (/\s/.test(body[i])) {
+			i += 1;
+			continue;
+		}
+		entry.lastIndex = i;
+		const match = entry.exec(body);
+		if (!match) return null;
+		const open = i + match[0].length;
+		const close = closingBrace(body, open);
+		if (close < 0) return null;
+		blocks.push({
+			name: match[1],
+			body: body.slice(open, close)
+		});
+		i = close + 1;
+	}
+	return blocks;
+}
+function parseDimensionNames(text) {
+	const statements = [...text.matchAll(/\bflavorDimensions\b([^\n]*)/g)];
+	if (statements.length === 0) return void 0;
+	const names = [];
+	for (const statement of statements) {
+		const line = statement[1] ?? "";
+		for (const quoted of line.matchAll(/(["'])([^"']*)\1/g)) names.push(quoted[2]);
+		if (line.replace(/(["'])[^"']*\1/g, "").replace(/[[\]()=+,;]/g, "").trim() !== "") return null;
+	}
+	return names.length ? names : null;
+}
+function declaredDimensionOf(flavorBody) {
+	const match = /\bdimension\b\s*=?\s*(["'])([^"']*)\1/.exec(flavorBody);
+	return match ? match[2] : null;
+}
+function parseProductFlavors(source) {
+	if (typeof source !== "string") return UNKNOWN_FLAVORS;
+	const text = stripGroovyComments(source);
+	if (/\bvariantFilter\b/.test(text)) return UNKNOWN_FLAVORS;
+	if (!/\bproductFlavors\b/.test(text)) return {
+		known: true,
+		dimensions: []
+	};
+	const body = productFlavorsBody(text);
+	if (body === null) return UNKNOWN_FLAVORS;
+	const flavors = parseFlavorBlocks(body);
+	if (!flavors) return UNKNOWN_FLAVORS;
+	if (flavors.length === 0) return {
+		known: true,
+		dimensions: []
+	};
+	const declared = parseDimensionNames(text);
+	if (declared === null) return UNKNOWN_FLAVORS;
+	const named = flavors.map((flavor) => declaredDimensionOf(flavor.body));
+	const used = [...new Set(named.filter((name) => name !== null))];
+	if (!declared || declared.length === 1) {
+		const only = declared ? declared[0] : used[0];
+		if (used.some((name) => name !== only)) return UNKNOWN_FLAVORS;
+		return {
+			known: true,
+			dimensions: [flavors.map((flavor) => flavor.name)]
+		};
+	}
+	if (named.some((name) => name === null || !declared.includes(name))) return UNKNOWN_FLAVORS;
+	const dimensions = [];
+	for (const dimension of declared) {
+		const group = flavors.filter((_, i) => named[i] === dimension).map((flavor) => flavor.name);
+		if (group.length === 0) return UNKNOWN_FLAVORS;
+		dimensions.push(group);
+	}
+	return {
+		known: true,
+		dimensions
+	};
+}
+function readProductFlavors(root) {
+	return parseProductFlavors(readOrNull(join(androidDir(root), "app", "build.gradle")));
+}
+function productFlavorRefusal({ flavors, variant }) {
+	if (variant) return null;
+	if (!flavors.known || flavors.dimensions.length === 0) return null;
+	let combinations = [[]];
+	for (const group of flavors.dimensions) combinations = combinations.flatMap((combination) => group.map((flavor) => combination.concat(flavor)));
+	if (combinations.length < 2) return null;
+	const count = flavors.dimensions.reduce((total, group) => total + group.length, 0);
+	const variants = combinations.map((combination) => variantNameOf(combination.concat("debug")));
+	return {
+		code: "STIM_BAD_ARG",
+		reason: `android/app/build.gradle declares ${count} product flavors, so \`./gradlew ${ASSEMBLE_TASK}\` builds an APK for each of them and nothing says which flavor to install.`,
+		remedy: `Pass \`--variant ${variants[0]}\` or set the android.variant setting -- e.g. {"android": {"variant": "${variants[0]}"}} in .stim.json. The debug variants are: ${variants.join(", ")}.`
+	};
+}
+function gradleArgs(task, { buildCache = true, abi = null } = {}) {
+	return [
+		task,
+		...buildCache ? ["--build-cache"] : ["--no-build-cache"],
+		...abi ? [`-PreactNativeArchitectures=${abi}`] : []
+	];
+}
+async function buildAndroid({ root, logWriter, variant = null, abi = null }, { spawnFn = null, now = Date.now, env = process.env, buildCache = true, ccache = null, cas = null, pch = "auto", compilerCacheDisabled = false, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), onNote = (line) => console.error(line) } = {}) {
+	const project = discoverAndroidProject(root);
+	if (project.failed) return {
+		...project,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: [],
+		durationMs: 0
+	};
+	const sdk = androidHome();
+	const refusal = androidSdkRefusal({
+		sdkPath: sdk,
+		sdkExists: existsSync(sdk),
+		hasLocalProperties: existsSync(join(project.androidDir, "local.properties"))
+	});
+	if (refusal) return {
+		failed: true,
+		...refusal,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: [],
+		durationMs: 0
+	};
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const task = assembleTaskFor(variant);
+	const args = gradleArgs(task, {
+		buildCache,
+		abi
+	});
+	if (cas) {
+		args.push("--init-script", cas.initScript);
+		onNote(chalk.dim(phaseLine("cache", `Apple Clang CAS on (${cas.dir})`)));
+	}
+	const nativeScript = ["../shim/android-optimizations.gradle", "../../shim/android-optimizations.gradle"].map((path) => fileURLToPath(new URL(path, import.meta.url))).find((path) => existsSync(path));
+	if (!nativeScript) throw new Error("Stim installation is missing shim/android-optimizations.gradle.");
+	args.push("--init-script", nativeScript);
+	const nativeBackend = cas ? cas.id : ccache ? ccache.env.CMAKE_CXX_COMPILER_LAUNCHER : compilerCacheDisabled ? "none" : "project";
+	const nativeEnv = {
+		STIM_ANDROID_NATIVE_PROFILE: createHash("sha256").update(readFileSync(nativeScript)).update(JSON.stringify({
+			backend: nativeBackend,
+			pch
+		})).digest("hex").slice(0, 16),
+		STIM_ANDROID_PCH: pch,
+		STIM_ANDROID_CCACHE: ccache && !cas ? "on" : compilerCacheDisabled || cas ? "off" : "project"
+	};
+	if (compilerCacheDisabled) Object.assign(nativeEnv, {
+		CCACHE_DISABLE: "1",
+		CMAKE_C_COMPILER_LAUNCHER: "",
+		CMAKE_CXX_COMPILER_LAUNCHER: ""
+	});
+	if (ccache && !cas && pch === "auto") onNote(chalk.dim(phaseLine("cache", "CMake PCH off by default for ccache reuse (explicit project settings preserved)")));
+	else if (pch !== "auto") onNote(chalk.dim(phaseLine("cache", `CMake PCH ${pch} by configuration`)));
+	if (buildCache) onNote(chalk.dim(phaseLine("cache", "gradle build cache on (--build-cache, shared under the Gradle user home)")));
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `${project.gradlew} ${args.join(" ")}`,
+		event: "build_start"
+	});
+	const startedAt = now();
+	const tail = [];
+	const window = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		tail.push(msg);
+		if (tail.length > LAST_LINES) tail.shift();
+		window.push(msg);
+		if (window.length > TRANSCRIPT_LINES) window.shift();
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "gradle"
+		});
+	};
+	if (ccache) resetStatsLog(ccache.statsLog);
+	let child;
+	try {
+		child = spawn(project.gradlew, args, {
+			cwd: project.androidDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...env,
+				...ccache?.env,
+				...cas?.env,
+				...nativeEnv,
+				TERM: "dumb",
+				FORCE_COLOR: "0"
+			}
+		});
+	} catch (err) {
+		return spawnFailure(err, project, now() - startedAt);
+	}
+	const outReader = createLineReader(push);
+	const errReader = createLineReader(push);
+	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: () => now() - startedAt,
+		emit: onHeartbeat,
+		estimateMs
+	});
+	const result = await waitForChild(child);
+	stopHeartbeat();
+	outReader.flush();
+	errReader.flush();
+	const durationMs = now() - startedAt;
+	const transcript = window.join("\n");
+	const ccacheActivity = ccache ? readCcacheActivity(ccache.statsLog) : CCACHE_UNAVAILABLE;
+	if (result.error) return {
+		...spawnFailure(result.error, project, durationMs),
+		lastLines: tail.slice(),
+		ccache: ccacheActivity
+	};
+	if (result.code !== 0) {
+		const how = result.signal ? `signal ${result.signal}` : `exit code ${result.code}`;
+		const { shown, truncated } = capDiagnostics(extractGradleDiagnostics(transcript));
+		return {
+			failed: true,
+			code: BUILD_ERROR,
+			reason: `\`./gradlew ${task}\` failed (${how}).`,
+			diagnostics: shown,
+			truncated,
+			lastLines: tail.slice(),
+			durationMs,
+			ccache: ccacheActivity
+		};
+	}
+	const located = locateApk(root, transcript, variant);
+	if (!located.apkPath && located.candidates?.length) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `\`./gradlew ${task}\` left ${located.candidates.length} debug APKs under ${apkOutputsDir(root)}, and nothing says which flavor to install.`,
+		remedy: `Set the android.variant setting to the variant to install -- e.g. {"android": {"variant": "${variantNameOf(relative(apkOutputsDir(root), located.candidates[0]).split("/").slice(0, -1))}"}} in .stim.json.`,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: located.candidates.map((c) => relative(androidDir(root), c)),
+		durationMs,
+		ccache: ccacheActivity
+	};
+	if (!located.apkPath) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: variant ? `\`./gradlew ${task}\` succeeded but produced no APK under ${apkOutputsDir(root)} for variant "${variant}".` : `\`./gradlew ${task}\` succeeded but produced no APK in ${debugApkDir(root)}.`,
+		remedy: variant ? `Check that the android.variant setting ("${variant}") names a real variant (\`./gradlew :app:tasks\` lists the assemble tasks).` : `Check that ${task} builds the app module (\`./gradlew :app:${task}\` in android/) and that no flavour redirects the output.`,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: tail.slice(),
+		durationMs,
+		ccache: ccacheActivity
+	};
+	return {
+		ok: true,
+		apkPath: located.apkPath,
+		apkNote: located.note ?? null,
+		durationMs,
+		lastLines: tail.slice(),
+		ccache: ccacheActivity
+	};
+}
+function resetStatsLog(statsLog) {
+	try {
+		mkdirSync(dirname(statsLog), { recursive: true });
+		rmSync(statsLog, { force: true });
+	} catch {}
+}
+function spawnFailure(err, project, durationMs) {
+	const nodeErr = err;
+	const message = String(nodeErr?.message || err || "");
+	const permissionDenied = nodeErr?.code === "EACCES" || /EACCES|permission denied/i.test(message);
+	return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `Could not run ${project.gradlew}: ${message}`,
+		remedy: permissionDenied ? `Make the wrapper executable: \`chmod +x ${project.gradlew}\`.` : "Check that the gradle wrapper is intact (android/gradlew and android/gradle/wrapper/) and that JAVA_HOME points at a JDK 17 install.",
+		diagnostics: [],
+		truncated: 0,
+		lastLines: [],
+		durationMs
+	};
+}
+function baseName(file) {
+	const parts = String(file).split("/");
+	return parts[parts.length - 1] ?? String(file);
+}
+function safeList(dir) {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/engine/android-cas.ts
+const CAS_TOOLCHAIN_FIELDS = [
+	"clang",
+	"clangxx",
+	"lld",
+	"ar",
+	"ranlib",
+	"ndk",
+	"resourceDir"
+];
+const CAS_TOOLCHAIN_BINARIES = [
+	"clang",
+	"clangxx",
+	"lld",
+	"ar",
+	"ranlib"
+];
+function executableFile(path) {
+	try {
+		accessSync(path, constants.X_OK);
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function directory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function readAndroidCasToolchain(manifest) {
+	const toolchain = JSON.parse(readFileSync(manifest, "utf8"));
+	const missing = CAS_TOOLCHAIN_FIELDS.filter((field) => typeof toolchain?.[field] !== "string");
+	if (missing.length > 0) throw new Error(`${manifest} declares no ${missing.join(", ")}.`);
+	const notExecutable = CAS_TOOLCHAIN_BINARIES.filter((field) => !executableFile(toolchain[field]));
+	if (notExecutable.length > 0) throw new Error(`${manifest} names no executable ${notExecutable.join(", ")}.`);
+	if (!directory(toolchain.resourceDir)) throw new Error(`${manifest} names resourceDir ${toolchain.resourceDir}, which is not a directory.`);
+	const ndkProperties = readFileSync(join(toolchain.ndk, "source.properties"), "utf8");
+	const ndkVersion = /Pkg.Revision\s*=\s*([^\r\n]+)/.exec(ndkProperties)?.[1]?.trim();
+	if (!ndkVersion) throw new Error(`Missing NDK version in ${toolchain.ndk}/source.properties.`);
+	return {
+		toolchain,
+		ndkVersion,
+		ndkProperties
+	};
+}
+function resolveAndroidCompilerCache({ optimizations, use, env = process.env }) {
+	if (optimizations.android.compilerCache !== "cas") return {
+		cas: null,
+		optimizations
+	};
+	const manifest = optimizations.android.casToolchain;
+	try {
+		return {
+			cas: use(manifest),
+			optimizations
+		};
+	} catch (error) {
+		const fromEnvironment = Boolean(env.STIM_ANDROID_CAS_TOOLCHAIN);
+		return {
+			cas: null,
+			optimizations: {
+				...optimizations,
+				android: {
+					...optimizations.android,
+					compilerCache: "ccache",
+					compilerCacheFallback: {
+						key: fromEnvironment ? "STIM_ANDROID_CAS_TOOLCHAIN" : "optimizations.android.casToolchain",
+						reason: `could not be used: ${error.message.replace(/\.$/, "")}`,
+						fromEnvironment,
+						manifest
+					}
+				}
+			}
+		};
+	}
+}
+function resolveAndroidCas(root, env = process.env) {
+	const manifest = env.STIM_ANDROID_CAS_TOOLCHAIN;
+	if (!manifest) return null;
+	const { toolchain, ndkVersion, ndkProperties } = readAndroidCasToolchain(manifest);
+	const scripts = [
+		"shim/android-cas.gradle",
+		"shim/android-cas.toolchain.cmake",
+		"shim/android-cas-pch.cmake",
+		"dist/android-cas-compiler.mjs"
+	].map((name) => {
+		const path = [`../${name}`, `../../${name}`].map((candidate) => fileURLToPath(new URL(candidate, import.meta.url))).find((candidate) => existsSync(candidate));
+		if (!path) throw new Error(`Stim installation is missing ${name}.`);
+		return path;
+	});
+	const hash = createHash("sha256").update(JSON.stringify(toolchain));
+	for (const path of [
+		...scripts,
+		toolchain.clang,
+		toolchain.clangxx,
+		toolchain.lld,
+		toolchain.ar,
+		toolchain.ranlib
+	]) hash.update(readFileSync(path));
+	hash.update(ndkProperties);
+	const id = `apple-cas-${hash.digest("hex")}`;
+	const dir = join(getConfigDir(), "android-cas", id);
+	const state = join(ensureWorkspaceStorage(root), "android-cas", id);
+	const context = join(state, "context.json");
+	mkdirSync(state, { recursive: true });
+	mkdirSync(dir, { recursive: true });
+	withDirLock(join(state, "setup.lock"), () => {
+		for (const name of ["clang", "clang++"]) {
+			const path = join(state, name);
+			const temporary = `${path}.${randomUUID()}.tmp`;
+			symlinkSync(scripts[3], temporary);
+			renameSync(temporary, path);
+		}
+		const temporary = `${context}.${process.pid}.tmp`;
+		writeFileSync(temporary, JSON.stringify({
+			...toolchain,
+			source: realpathSync(root),
+			state,
+			cache: dir
+		}));
+		renameSync(temporary, context);
+	});
+	register({
+		dir,
+		name: "android-cas",
+		prune: "atomic",
+		note: "Experimental Android compiler CAS"
+	});
+	return {
+		id,
+		dir,
+		initScript: scripts[0],
+		env: {
+			STIM_ANDROID_CAS_CONTEXT: context,
+			STIM_ANDROID_CAS_SOURCE_ROOT: realpathSync(root),
+			STIM_ANDROID_CAS_STATE: state,
+			STIM_ANDROID_CAS_NDK: toolchain.ndk,
+			STIM_ANDROID_CAS_NDK_VERSION: ndkVersion,
+			STIM_ANDROID_CAS_AR: toolchain.ar,
+			STIM_ANDROID_CAS_RANLIB: toolchain.ranlib,
+			STIM_ANDROID_CAS_CMAKE_TOOLCHAIN: scripts[1],
+			STIM_ANDROID_CAS_CMAKE_PCH: scripts[2],
+			CMAKE_C_COMPILER_LAUNCHER: "",
+			CMAKE_CXX_COMPILER_LAUNCHER: "",
+			CCACHE_DISABLE: "1"
+		}
+	};
+}
+//#endregion
+export { buildAndroid as a, CCACHE_NOT_RUN as c, projectCmakeLauncher as d, resolveCcache as f, apkOutputsDir as i, CCACHE_UNAVAILABLE as l, resolveAndroidCas as n, productFlavorRefusal as o, formatDiagnostic as p, resolveAndroidCompilerCache as r, readProductFlavors as s, readAndroidCasToolchain as t, ccacheActivityLine as u };