stim 1.0.0 → 1.2.0

package/dist/doctor-CqPeMsSm.mjs

@@ -0,0 +1,1130 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { g as loadConfig, l as getConcurrencyLimits, o as configCorruptRepair } from "./config-CMtIaTk9.mjs";
+import { b as sharedBuildCache, w as workspaceDerivedData } from "./state-CZ-ER-8d.mjs";
+import { S as makeTemporaryDirectory, a as dirtyFingerprintFiles, f as listWorktrees, g as repoRoot, s as gitCommonDir, w as temporaryRoot, x as filesystemDevice } from "./worktree-C79xx_kM.mjs";
+import { i as detectIsExpo, t as appProjectProblem } from "./project-BBTVABUz.mjs";
+import { d as resolveEasCliBin, i as checkEasAuth$1, l as ownerFromConfig, u as providerFromConfig, v as POOL_SETTING_REMEDY, x as parkedMaxSetting } from "./remote-cache-DDmJ1Roq.mjs";
+import { A as resolveSettings, E as remoteAndroidSetting, I as unknownSettingKeys, M as settingOrigin, N as settingShapeErrors, O as remoteIosSetting, P as settingsLayers, U as resolveOptimizations, V as compilerCacheFallbackMessage, a as SETTING_SHAPE_REMEDY, i as SETTINGS_WITH_RESOLVE_TIME_FALLBACK, n as PATH_SETTINGS, v as iosSimSlimProfileSetting, w as projectOptimizations, y as mergeSettingsLayers } from "./settings-DwU1_U_q.mjs";
+import { d as quotedPath, u as plural } from "./command-output-8wHMEde0.mjs";
+import { E as readHostMemoryPressure, T as hostMemoryPressureAdvice, u as listAllIosSims } from "./ios-D1h1Di39.mjs";
+import { m as fingerprintProject, r as listBuildLocks, u as diffFingerprintSources } from "./build-lock-BsVoLDaq.mjs";
+import { n as listBuildSlots } from "./build-slots-D0b6sJyo.mjs";
+import { y as listAdbDevices } from "./android-K63_0UfF.mjs";
+import { E as simslimIsOnPath, S as liveOwnedDeviceCount, a as ccacheEnabled, g as podInstallCommand } from "./xcode-DeKCribl.mjs";
+import { d as projectCmakeLauncher, i as apkOutputsDir, r as resolveAndroidCompilerCache, t as readAndroidCasToolchain } from "./android-cas-D6HPZ6UQ.mjs";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync as existsSync$1, lstatSync as lstatSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1 } from "fs";
+import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
+import * as expoFingerprint from "@expo/fingerprint";
+//#region src/doctor-storage.ts
+function checkStorageLayout(projectRoot, { platform, device = filesystemDevice, stagingRoot = temporaryRoot } = {}) {
+	const findings = [];
+	const temporaryFix = "Unset STIM_TMPDIR / machine tempDir to select same-volume staging automatically, or point the override at a writable directory on the relevant volume outside Git working trees.";
+	const check = (operation, paths, fix) => {
+		if (new Set(paths.map(device)).size < 2) return;
+		findings.push({
+			level: "cost",
+			title: `${operation} crosses filesystems`,
+			detail: `${paths.join(" -> ")}. These copies cannot share file blocks across volumes and can consume the full artifact size in space and I/O. cp -c can silently perform a full copy without an error.`,
+			fix
+		});
+	};
+	try {
+		const target = repoRoot(projectRoot) ?? projectRoot;
+		check("Worktree copy", [listWorktrees(target)[0]?.path ?? target, target], "Keep the source checkout and linked worktree on the same volume to share file blocks when warming.");
+		const cache = sharedBuildCache();
+		check("Cached app/APK staging", [cache, stagingRoot(join(cache, "artifact.app"))], temporaryFix);
+		const cacheFix = "Place STIM_BUILD_CACHE / machine caches.buildCache on the build-output volume, or accept the full-copy cost of keeping the cache on a separate volume.";
+		if (platform === "ios" || platform !== "android" && existsSync(join(projectRoot, "ios"))) {
+			const output = join(workspaceDerivedData(projectRoot), "Build", "Products");
+			check("iOS build-cache storage", [output, cache], cacheFix);
+			check("iOS device app staging", [output, stagingRoot(join(output, "artifact.app"))], temporaryFix);
+		}
+		if (platform === "android" || platform !== "ios" && existsSync(join(projectRoot, "android"))) check("Android build-cache storage", [apkOutputsDir(projectRoot), cache], cacheFix);
+	} catch (error) {
+		findings.push({
+			level: "cost",
+			title: "Could not resolve temporary storage",
+			detail: String(error.message),
+			fix: temporaryFix
+		});
+	}
+	return findings;
+}
+//#endregion
+//#region src/doctor-ios-architectures.ts
+const COMPILED_PRODUCTS = /* @__PURE__ */ new Set([
+	"com.apple.product-type.application",
+	"com.apple.product-type.application.on-demand-install-capable",
+	"com.apple.product-type.app-extension",
+	"com.apple.product-type.framework",
+	"com.apple.product-type.library.static",
+	"com.apple.product-type.library.dynamic"
+]);
+function architectureList(value) {
+	if (typeof value !== "string" || /[^\w\s-]/.test(value)) return null;
+	return [...new Set(value.split(/\s+/).filter(Boolean))];
+}
+function parseIosDebugArchitectures(output) {
+	const report = {
+		affected: [],
+		unknown: false
+	};
+	let data;
+	try {
+		data = JSON.parse(output);
+	} catch {
+		return {
+			...report,
+			unknown: true
+		};
+	}
+	if (!Array.isArray(data) || data.length === 0) return {
+		...report,
+		unknown: true
+	};
+	let inspected = false;
+	for (const entry of data) {
+		if (!entry || typeof entry !== "object" || entry.error || !entry.buildSettings) {
+			report.unknown = true;
+			continue;
+		}
+		const settings = entry.buildSettings;
+		if (settings.CONFIGURATION !== "Debug" || settings.PLATFORM_NAME !== "iphonesimulator") {
+			report.unknown = true;
+			continue;
+		}
+		if (!settings.PRODUCT_TYPE) continue;
+		if (settings.PRODUCT_TYPE === "com.apple.product-type.bundle") {
+			inspected = true;
+			continue;
+		}
+		if (!COMPILED_PRODUCTS.has(settings.PRODUCT_TYPE)) {
+			report.unknown = true;
+			continue;
+		}
+		inspected = true;
+		if (settings.ONLY_ACTIVE_ARCH === "YES") continue;
+		const archs = architectureList(settings.ARCHS);
+		const valid = settings.VALID_ARCHS === void 0 ? archs : architectureList(settings.VALID_ARCHS);
+		const excluded = architectureList(settings.EXCLUDED_ARCHS ?? "");
+		if (settings.ONLY_ACTIVE_ARCH !== "NO" || !archs?.length || !valid || !excluded || typeof entry.target !== "string") {
+			report.unknown = true;
+			continue;
+		}
+		const architectures = archs.filter((arch) => valid.includes(arch) && !excluded.includes(arch));
+		if (architectures.length > 1) report.affected.push({
+			target: entry.target,
+			architectures
+		});
+	}
+	return {
+		...report,
+		unknown: report.unknown || !inspected
+	};
+}
+function inspectIosDebugArchitectures(projectRoot) {
+	const iosRoot = join(projectRoot, "ios");
+	if (!existsSync(iosRoot)) return [];
+	const findings = [];
+	const unknown = [];
+	let projects;
+	try {
+		projects = readdirSync(iosRoot).filter((name) => name.endsWith(".xcodeproj")).toSorted().map((name) => join(iosRoot, name));
+	} catch {
+		projects = [];
+	}
+	if (!projects.length) unknown.push("app project");
+	const pods = join(iosRoot, "Pods", "Pods.xcodeproj");
+	if (existsSync(pods)) projects.push(pods);
+	else if (existsSync(join(iosRoot, "Podfile"))) unknown.push("Pods project (not generated)");
+	const deadline = Date.now() + 6e4;
+	for (const project of projects) {
+		const label = relative(projectRoot, project);
+		const timeoutMs = Math.min(3e4, deadline - Date.now());
+		if (timeoutMs <= 0) {
+			unknown.push(label);
+			continue;
+		}
+		try {
+			const report = parseIosDebugArchitectures(getExecutor().runFile("xcodebuild", [
+				"-project",
+				project,
+				"-alltargets",
+				"-configuration",
+				"Debug",
+				"-sdk",
+				"iphonesimulator",
+				"-showBuildSettings",
+				"-json",
+				"-disableAutomaticPackageResolution",
+				"-skipPackageUpdates"
+			], {
+				cwd: iosRoot,
+				timeoutMs
+			}));
+			if (report.unknown) unknown.push(label);
+			if (report.affected.length) {
+				const targets = report.affected.slice(0, 5).map(({ target, architectures }) => `${target} (${architectures.join(", ")})`).join("; ");
+				findings.push({
+					code: "ios-debug-architectures",
+					level: "cost",
+					title: "iOS Debug targets build multiple simulator architectures",
+					detail: `${label}: ${report.affected.length} Debug target(s) resolve ONLY_ACTIVE_ARCH=NO with multiple architectures after exclusions: ${targets}${report.affected.length > 5 ? `; plus ${report.affected.length - 5} more` : ""}. This can compile extra native code when targeting one simulator.`,
+					fix: "Review the Debug ONLY_ACTIVE_ARCH override in the project, xcconfig, or Podfile post_install helpers. Prefer YES for local Debug simulator builds where appropriate; preserve intentional Release and distribution settings. Regenerate Pods through the project workflow after changing a helper, then rerun stim doctor --platform ios. Doctor --fix does not change architecture settings."
+				});
+			}
+		} catch {
+			unknown.push(label);
+		}
+	}
+	if (unknown.length) findings.push({
+		code: "ios-debug-architectures-unknown",
+		level: "note",
+		title: "iOS Debug architecture settings could not be fully inspected",
+		detail: `Effective Debug simulator settings are unavailable for ${unknown.join(", ")}. Architecture policy is not verified for those targets. Metadata inspection has a 60-second total budget.`,
+		fix: "Ensure Xcode can read the generated app and Pods projects, then rerun stim doctor --platform ios. Doctor does not evaluate Podfiles or install Pods to inspect architecture settings."
+	});
+	return findings;
+}
+//#endregion
+//#region src/doctor-cxx.ts
+function parseCmakeCacheLauncher(source) {
+	if (typeof source !== "string") return null;
+	return /^CMAKE_CXX_COMPILER_LAUNCHER(?::[A-Z]+)?=(.*)$/m.exec(source)?.[1]?.trim() || null;
+}
+function children(path) {
+	try {
+		return readdirSync(path).toSorted();
+	} catch (error) {
+		if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) return [];
+		throw error;
+	}
+}
+function moduleRoots(root) {
+	const modules = [join(root, "android", "app")];
+	const dependencies = join(root, "node_modules");
+	for (const name of children(dependencies)) {
+		if (name.startsWith(".")) continue;
+		const entry = join(dependencies, name);
+		const packages = name.startsWith("@") ? children(entry).map((child) => join(entry, child)) : [entry];
+		modules.push(...packages.map((pkg) => join(pkg, "android")));
+	}
+	return modules;
+}
+function cacheFiles(base, depth = 0) {
+	const files = [];
+	for (const name of children(base)) {
+		if (depth === 0 && /^stim-[a-f0-9]{16}$/.test(name)) continue;
+		const path = join(base, name);
+		const entry = lstatSync(path);
+		if (entry.isSymbolicLink()) continue;
+		if (name === "CMakeCache.txt" && entry.isFile()) files.push(path);
+		else if (depth < 3 && entry.isDirectory() && name !== "CMakeFiles") files.push(...cacheFiles(path, depth + 1));
+	}
+	return files;
+}
+function readCxxLauncherStates(root) {
+	return moduleRoots(root).flatMap((module) => cacheFiles(join(module, ".cxx")).map((path) => ({
+		path: relative(root, path),
+		launcher: parseCmakeCacheLauncher(readFileSync(path, "utf8"))
+	})));
+}
+function declaredLauncher(module) {
+	return [
+		"build.gradle",
+		"build.gradle.kts",
+		"CMakeLists.txt"
+	].some((name) => {
+		const path = join(module, name);
+		return existsSync(path) && Boolean(projectCmakeLauncher(readFileSync(path, "utf8")));
+	});
+}
+function contained(root, path) {
+	const rel = relative(root, path);
+	return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function selectedCompilerCache(root) {
+	try {
+		return resolveAndroidCompilerCache({
+			optimizations: projectOptimizations(root),
+			use: readAndroidCasToolchain
+		}).optimizations.android.compilerCache;
+	} catch {
+		return null;
+	}
+}
+/**
+* Keep every native build stopped until repair finishes. The supplemental
+* cache-lock check cannot detect uncached builds, release-swap fallback, or direct Gradle.
+*/
+function repairCxxLauncherState(root) {
+	const canonicalRoot = realpathSync(root);
+	const result = {
+		removed: [],
+		refused: []
+	};
+	if (selectedCompilerCache(root) !== "ccache") return result;
+	if (!getExecutor().runQuiet("command -v ccache", { timeoutMs: 5e3 })) return result;
+	const appOverrides = declaredLauncher(join(root, "android", "app"));
+	const targets = readCxxLauncherStates(root).filter(({ launcher }) => {
+		if (!launcher) return true;
+		const command = launcher.split(";")[0]?.trim();
+		return Boolean(command && isAbsolute(command) && basename(command) === "ccache" && !existsSync(command));
+	});
+	for (const state of targets) {
+		const target = dirname(join(root, state.path));
+		const label = relative(root, target);
+		try {
+			let cxx = target;
+			while (contained(root, cxx) && basename(cxx) !== ".cxx") cxx = dirname(cxx);
+			if (basename(cxx) !== ".cxx" || target === cxx) throw new Error("unrecognized generated CMake layout");
+			if (appOverrides || declaredLauncher(dirname(cxx))) throw new Error("project configures its own compiler launcher");
+			const canonicalTarget = realpathSync(target);
+			if (!contained(canonicalRoot, canonicalTarget)) throw new Error("generated directory resolves outside this checkout");
+			if (realpathSync(cxx) !== join(realpathSync(dirname(cxx)), ".cxx")) throw new Error(".cxx is a symbolic link");
+			const gitPath = relative(canonicalRoot, canonicalTarget);
+			if (getExecutor().runFile("git", [
+				"ls-files",
+				"-z",
+				"--",
+				`:(literal)${gitPath}`
+			], {
+				cwd: canonicalRoot,
+				timeoutMs: 5e3
+			})) throw new Error("directory contains tracked files");
+			getExecutor().runFile("git", [
+				"check-ignore",
+				"-q",
+				"--",
+				gitPath
+			], {
+				cwd: canonicalRoot,
+				timeoutMs: 5e3
+			});
+			const androidLocks = listBuildLocks().filter((lock) => lock.platform === "android");
+			if (androidLocks.some((lock) => lock.unresolved)) throw new Error("an Android build lock holder cannot be identified, so a build may be active");
+			if (androidLocks.some((lock) => {
+				if (!lock.alive || !lock.projectRoot) return false;
+				return realpathSync(lock.projectRoot) === canonicalRoot;
+			})) throw new Error("an Android build is active in this checkout");
+			if (realpathSync(target) !== canonicalTarget) throw new Error("directory changed during inspection");
+			rmSync(target, { recursive: true });
+			result.removed.push(label);
+		} catch (error) {
+			result.refused.push({
+				path: label,
+				reason: error.message
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/doctor-config.ts
+function readMachineSettings(context) {
+	try {
+		const layers = settingsLayers(context);
+		return {
+			settings: mergeSettingsLayers(layers.map((layer) => layer.settings)),
+			layers,
+			corrupt: null
+		};
+	} catch (error) {
+		if (error.code !== "STIM_CONFIG_CORRUPT") throw error;
+		return {
+			settings: {},
+			layers: [],
+			corrupt: {
+				level: "note",
+				title: "The Stim config is not valid JSON",
+				detail: `${String(error.message).split("\n")[0]}. Every setting and device record lives in that file, so no other machine-level check can run until it parses.`,
+				fix: configCorruptRepair()
+			}
+		};
+	}
+}
+const PATH_SETTING_ENVIRONMENT = { "optimizations.android.casToolchain": "STIM_ANDROID_CAS_TOOLCHAIN" };
+const PATH_SETTINGS_TRIMMED_BY_THEIR_CONSUMER = /* @__PURE__ */ new Set(["android.keystore"]);
+function checkMachineSettings({ settings, layers, projectRoot, optimizations = null, reportedElsewhere = [], exists = existsSync, env = process.env }) {
+	const findings = [];
+	const fallback = optimizations?.android.compilerCacheFallback ?? null;
+	const fallbackEntry = fallback ? settingOrigin(layers, fallback.key) : null;
+	const attributed = fallback && (fallback.fromEnvironment || fallbackEntry) ? fallback : null;
+	const reported = attributed?.manifest && !exists(attributed.manifest) ? null : attributed;
+	const skip = new Set(reportedElsewhere);
+	if (reported) skip.add(reported.key);
+	if (!optimizations) for (const key of SETTINGS_WITH_RESOLVE_TIME_FALLBACK) skip.add(key);
+	for (const key of PATH_SETTINGS) {
+		const variable = PATH_SETTING_ENVIRONMENT[key];
+		if (skip.has(key) || variable && skip.has(variable)) continue;
+		const override = variable ? env[variable] : void 0;
+		if (variable && override) {
+			const named = missingPath(override, projectRoot, exists);
+			if (named) findings.push({
+				level: "note",
+				title: "An environment variable points at a path that is not there",
+				detail: `${variable} in the environment names ${named}, which does not exist.`,
+				fix: `Point ${variable} at the path it should name, or unset it.`
+			});
+			continue;
+		}
+		const entry = settingOrigin(layers, key);
+		if (!entry || typeof entry.value !== "string") continue;
+		const named = missingPath(entry.value, projectRoot, exists, PATH_SETTINGS_TRIMMED_BY_THEIR_CONSUMER.has(key));
+		if (!named) continue;
+		findings.push({
+			level: "note",
+			title: "A setting points at a path that is not there",
+			detail: `${key} in ${entry.file} names ${named}, which does not exist.`,
+			fix: `Point ${key} at the path it should name, or remove it from ${entry.file}.`
+		});
+	}
+	if (reported && optimizations) findings.push(compilerCacheFinding({
+		fallback: reported,
+		optimizations,
+		file: fallbackEntry?.file ?? null
+	}));
+	for (const key of unknownSettingKeys(settings)) {
+		const file = settingOrigin(layers, key)?.file ?? null;
+		findings.push({
+			level: "note",
+			title: "A key in the config is inert",
+			detail: `${key}${file ? ` in ${file}` : ""} is not read by Stim, so its value changes nothing.`,
+			fix: `Remove ${key}${file ? ` from ${file}` : ""}, or run \`stim guide settings\` for the name that replaced it.`
+		});
+	}
+	return findings;
+}
+function compilerCacheFinding({ fallback, optimizations, file }) {
+	const detail = compilerCacheFallbackMessage({
+		fallback,
+		compilerCache: optimizations.android.compilerCache === "none" ? "none" : "ccache",
+		file
+	});
+	if (fallback.key === "optimizations.android.compilerCache") return {
+		level: "note",
+		title: "A setting needs a companion this config does not supply",
+		detail,
+		fix: "Set optimizations.android.casToolchain to the toolchain JSON manifest, or set optimizations.android.compilerCache to ccache."
+	};
+	const title = fallback.fromEnvironment ? "An environment variable holds a value Stim cannot use" : "A setting holds a value Stim cannot use";
+	if (fallback.manifest) return {
+		level: "note",
+		title,
+		detail,
+		fix: `Repair ${fallback.manifest}, or ${fallback.fromEnvironment ? `unset ${fallback.key}` : `remove ${fallback.key}${file ? ` from ${file}` : ""}`}.`
+	};
+	return {
+		level: "note",
+		title,
+		detail,
+		fix: fallback.fromEnvironment ? "Point STIM_ANDROID_CAS_TOOLCHAIN at an absolute path to the toolchain JSON manifest, or unset it." : "Set optimizations.android.casToolchain to an absolute path to the toolchain JSON manifest, or remove it."
+	};
+}
+function missingPath(value, projectRoot, exists, trim = false) {
+	const opened = trim ? value.trim() : value;
+	if (opened.trim() === "") return null;
+	const path = isAbsolute(opened) ? opened : resolve(projectRoot, opened);
+	if (exists(path)) return null;
+	return opened === opened.trim() ? path : JSON.stringify(path);
+}
+//#endregion
+//#region src/doctor.ts
+function finding(level, title, detail, fix) {
+	return {
+		level,
+		title,
+		detail,
+		fix
+	};
+}
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync$1(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function mainCheckoutProjectRoot(projectRoot) {
+	const currentRepoRoot = repoRoot(projectRoot);
+	if (!currentRepoRoot) return projectRoot;
+	try {
+		const main = listWorktrees(currentRepoRoot)[0];
+		if (!main) return projectRoot;
+		const projectRel = relative$1(currentRepoRoot, realpathSync$1(projectRoot));
+		if (projectRel.startsWith("..")) return projectRoot;
+		return resolve$1(main.path, projectRel);
+	} catch {
+		return projectRoot;
+	}
+}
+function installedNpmTreeIsValid(projectRoot) {
+	try {
+		getExecutor().runFile("npm", [
+			"ls",
+			"--all",
+			"--json",
+			"--silent"
+		], {
+			cwd: projectRoot,
+			timeoutMs: 3e4
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+const DEPENDENCY_STATES = [
+	{
+		lock: "pnpm-lock.yaml",
+		installed: ["node_modules"],
+		command: "pnpm install"
+	},
+	{
+		lock: "yarn.lock",
+		installed: [
+			"node_modules",
+			".pnp.cjs",
+			".pnp.js"
+		],
+		command: "yarn install"
+	},
+	{
+		lock: "bun.lock",
+		installed: ["node_modules"],
+		command: "bun install"
+	},
+	{
+		lock: "bun.lockb",
+		installed: ["node_modules"],
+		command: "bun install"
+	},
+	{
+		lock: "package-lock.json",
+		installed: ["node_modules"],
+		command: "npm ci"
+	}
+];
+function dependencyState(projectRoot) {
+	const root = repoRoot(projectRoot) ?? projectRoot;
+	let dir = projectRoot;
+	while (true) {
+		const state = DEPENDENCY_STATES.find((candidate) => existsSync$1(join$1(dir, candidate.lock)));
+		if (state) return {
+			...state,
+			root: dir
+		};
+		if (dir === root) return null;
+		const parent = dirname$1(dir);
+		if (parent === dir || relative$1(root, parent).startsWith("..")) return null;
+		dir = parent;
+	}
+}
+function hasInstalledDependencies(projectRoot, markers = [
+	"node_modules",
+	".pnp.cjs",
+	".pnp.js"
+]) {
+	return markers.some((entry) => existsSync$1(join$1(projectRoot, entry)));
+}
+function locallyKnownUpstream(projectRoot) {
+	try {
+		const name = getExecutor().runFile("git", [
+			"-C",
+			projectRoot,
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		], { timeoutMs: 5e3 });
+		const counts = getExecutor().runFile("git", [
+			"-C",
+			projectRoot,
+			"rev-list",
+			"--left-right",
+			"--count",
+			"HEAD...@{upstream}"
+		], { timeoutMs: 5e3 }).trim().split(/\s+/).map(Number);
+		const ahead = counts[0] ?? NaN;
+		const behind = counts[1] ?? NaN;
+		if (!name || !Number.isInteger(ahead) || !Number.isInteger(behind)) return null;
+		return {
+			name,
+			ahead,
+			behind
+		};
+	} catch {
+		return null;
+	}
+}
+function brokenPodLinks(podsRoot) {
+	try {
+		return getExecutor().runFile("find", [
+			"-L",
+			podsRoot,
+			"-type",
+			"l",
+			"-print"
+		], { timeoutMs: 1e4 }).split("\n").map((line) => line.trim()).filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+function hasIosWarmOutput(root) {
+	if (existsSync$1(join$1(root, "ios", "build"))) return true;
+	const derivedData = workspaceDerivedData(root);
+	if (existsSync$1(join$1(derivedData, "Build", "Products"))) return true;
+	try {
+		return readdirSync$1(derivedData).some((entry) => /^scheme-[a-f0-9]{64}$/.test(entry) && existsSync$1(join$1(derivedData, entry, "Build", "Products")));
+	} catch {
+		return false;
+	}
+}
+function hasLinkedWorktree(projectRoot) {
+	const root = repoRoot(projectRoot);
+	if (!root) return false;
+	return listWorktrees(root).filter((entry) => !entry.prunable).length > 1;
+}
+function headBranch(root) {
+	const ref = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	])?.trim();
+	return ref?.startsWith("refs/heads/") ? ref.slice(11) : null;
+}
+function mainOperation(root) {
+	const gitDir = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir"
+	])?.trim();
+	if (!gitDir) return null;
+	if (existsSync$1(join$1(gitDir, "rebase-merge")) || existsSync$1(join$1(gitDir, "rebase-apply"))) return "rebase";
+	return existsSync$1(join$1(gitDir, "MERGE_HEAD")) ? "merge" : null;
+}
+function dirtyTrackedPaths(root) {
+	return (getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"diff",
+		"--name-only",
+		"HEAD"
+	]) ?? "").split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function resolveDefaultBranch(root) {
+	const worktree = resolveSettings({
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root) ?? root
+	}).worktree;
+	const configured = worktree && typeof worktree === "object" && !Array.isArray(worktree) ? worktree.defaultBranch : void 0;
+	if (typeof configured === "string" && configured.trim()) return configured.trim();
+	const head = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"symbolic-ref",
+		"--short",
+		"refs/remotes/origin/HEAD"
+	])?.trim();
+	if (!head) return null;
+	const cut = head.indexOf("/");
+	return cut > 0 ? head.slice(cut + 1) : head;
+}
+function seedFindings(mainRoot, upstream) {
+	const findings = [];
+	const root = repoRoot(mainRoot);
+	const quotedRoot = quotedPath(root ?? mainRoot);
+	if (upstream && upstream.behind > 0 && upstream.ahead === 0) findings.push(finding("note", `The source checkout is ${plural(upstream.behind, "commit")} behind ${upstream.name}`, "The count uses the locally known upstream ref. A fetch can reveal additional commits. A later rebase or merge can change native inputs and invalidate work done from the older base.", `Run \`stim worktree warm --refresh\` from a linked worktree to fetch and fast-forward the source checkout, or \`git -C ${quotedRoot} fetch --prune\` and inspect the branch yourself.`));
+	if (root === null) return findings;
+	const operation = mainOperation(root);
+	if (operation) {
+		findings.push(finding("note", `The source checkout has a ${operation} in progress`, "`stim worktree warm --refresh` refuses a source checkout it cannot move, and the branch stays where the interrupted operation left it.", `Finish it, or run \`git -C ${quotedRoot} ${operation} --abort\`.`));
+		return findings;
+	}
+	const dirty = dirtyTrackedPaths(root);
+	if (dirty.length) findings.push(finding("note", `The source checkout has ${plural(dirty.length, "uncommitted tracked change")}`, `\`stim worktree warm --refresh\` refuses a source checkout it cannot move, so the seed stays where it is until this is cleared. First: ${dirty[0]}.`, `Commit them, or run \`git -C ${quotedRoot} stash push -u -m warm-refresh\`.`));
+	const branch = headBranch(root);
+	if (branch === null) {
+		findings.push(finding("note", "The source checkout has a detached HEAD", "`stim worktree warm --refresh` refuses: there is no branch to fast-forward.", `Run \`git -C ${quotedRoot} checkout <branch>\`.`));
+		return findings;
+	}
+	if (upstream && upstream.ahead > 0 && upstream.behind > 0) findings.push(finding("note", `The source checkout has diverged from ${upstream.name}`, `${branch} is ${upstream.ahead} ahead of and ${upstream.behind} behind ${upstream.name}, so it cannot fast-forward. \`stim worktree warm --refresh\` refuses rather than merging or resetting.`, `Rebase or merge ${branch} onto ${upstream.name} yourself.`));
+	const defaultBranch = resolveDefaultBranch(root);
+	if (defaultBranch !== null && defaultBranch !== branch) findings.push(finding("note", `The source checkout is on ${branch}, not the default branch ${defaultBranch}`, `Every worktree warmed from here carries ${branch}'s dependencies. \`stim worktree warm --refresh\` warns and continues; it never switches a branch under another checkout.`, `Run \`git -C ${quotedRoot} checkout ${defaultBranch}\`.`));
+	return findings;
+}
+function checkMainCheckout(projectRoot, { npmTreeValid, brokenPods = void 0, upstream = void 0, linkedWorktrees = void 0, platform } = {}) {
+	const mainRoot = mainCheckoutProjectRoot(projectRoot);
+	const findings = [];
+	const dependencies = dependencyState(mainRoot);
+	if (dependencies) {
+		const installed = hasInstalledDependencies(dependencies.root, dependencies.installed);
+		const installCommand = `cd ${quotedPath(dependencies.root)} && ${dependencies.command}`;
+		if (!installed) findings.push(finding("cost", "The source checkout has no installed dependencies", `A worktree cannot carry dependencies from ${dependencies.root}, so its first build must install them from scratch.`, `Run \`${installCommand}\` before creating native worktrees, or let \`stim worktree warm --refresh\` run it from a linked worktree.`));
+		else if (dependencies.lock === "package-lock.json") {
+			if ((npmTreeValid === void 0 ? installedNpmTreeIsValid(dependencies.root) : npmTreeValid) === false) findings.push(finding("cost", "The source checkout dependency tree is stale", `npm reports that ${dependencies.root}/node_modules does not match the project dependency graph. Copying it makes each worktree start from the same invalid state.`, `Run \`${installCommand}\` before creating native worktrees, or let \`stim worktree warm --refresh\` run it from a linked worktree.`));
+		}
+	}
+	const podfileLock = join$1(mainRoot, "ios", "Podfile.lock");
+	const podManifest = join$1(mainRoot, "ios", "Pods", "Manifest.lock");
+	const podsRoot = join$1(mainRoot, "ios", "Pods");
+	if (platform !== "android" && existsSync$1(podfileLock)) {
+		let podsState = null;
+		if (!existsSync$1(podManifest)) podsState = "missing";
+		else try {
+			if (readFileSync$1(podfileLock, "utf-8") !== readFileSync$1(podManifest, "utf-8")) podsState = "stale";
+		} catch {
+			podsState = "stale";
+		}
+		if (podsState) {
+			const iosRoot = join$1(mainRoot, "ios");
+			const podCommand = `cd ${quotedPath(iosRoot)} && ${podInstallCommand(mainRoot)}`;
+			findings.push(finding("cost", `The source checkout CocoaPods state is ${podsState}`, `ios/Pods cannot be reused safely because its Manifest.lock ${podsState === "missing" ? "is absent" : "does not match ios/Podfile.lock"}.`, `Run \`${podCommand}\` before creating native worktrees, or let \`stim worktree warm --refresh\` run it from a linked worktree.`));
+		}
+		const broken = brokenPods === void 0 && existsSync$1(podsRoot) ? brokenPodLinks(podsRoot) : brokenPods || [];
+		if (broken.length) {
+			const iosRoot = join$1(mainRoot, "ios");
+			const podCommand = `cd ${quotedPath(iosRoot)} && ${podInstallCommand(mainRoot, "--clean-install")}`;
+			findings.push(finding("cost", "The source checkout CocoaPods state has broken links", `${broken.length} symlink${broken.length === 1 ? "" : "s"} under ios/Pods point to missing files. Worktrees copy these broken links and can fail during compilation. First: ${broken[0]}.`, `Run \`${podCommand}\` before creating native worktrees.`));
+		}
+	}
+	const coldPlatforms = [platform !== "android" && existsSync$1(join$1(mainRoot, "ios")) && !hasIosWarmOutput(mainRoot) ? "iOS" : null, platform !== "ios" && existsSync$1(join$1(mainRoot, "android")) && !existsSync$1(join$1(mainRoot, "android", "build")) && !existsSync$1(join$1(mainRoot, "android", "app", "build")) ? "Android" : null].filter((coldPlatform) => coldPlatform !== null);
+	if (coldPlatforms.length) findings.push(finding("note", `The source checkout has no ${coldPlatforms.join(" or ")} warm build output`, "The shared Stim artifact or compilation cache can still be warm. Building the source checkout once gives later native worktrees the strongest warm starting point.", `When more native worktrees are expected, run \`stim start\`, \`stim ${coldPlatforms[0] === "iOS" ? "ios" : "android"}\`, and \`stim stop\` from ${mainRoot}.`));
+	if (linkedWorktrees === void 0 ? hasLinkedWorktree(projectRoot) : linkedWorktrees) findings.push(...seedFindings(mainRoot, upstream === void 0 ? locallyKnownUpstream(mainRoot) : upstream));
+	return findings;
+}
+function checkMetroCache(metroConfigSource) {
+	if (metroConfigSource == null) return null;
+	const lines = String(metroConfigSource).split("\n");
+	const mentions = lines.filter((line) => /cacheStores/.test(line));
+	if (!mentions.length) return null;
+	if (!lines.every((line, i) => !/cacheStores/.test(line) || isConditional(lines, i))) return null;
+	return finding("note", "metro.config.js mentions cacheStores, but not unconditionally", `Every line naming it is inside a conditional, and doctor reads this file rather than executing it, so it cannot tell whether the store is installed. Under \`stim start\` this costs nothing -- Stim appends its own store whether the project's is on or off -- but outside Stim a cacheStores that is off by default costs exactly what having none costs: ${mentions.map((l) => l.trim()).join(" / ")}`, "Only for Metro runs Stim does not host: confirm it applies without env vars -- a store behind an opt-in flag is not shared until every workspace sets the flag.");
+}
+function isConditional(lines, index) {
+	const line = lines[index];
+	if (line === void 0) return false;
+	if (isConditionalLine(line)) return true;
+	if (!/^\s+\S/.test(line)) return false;
+	for (let i = index - 1; i >= 0; i--) {
+		const prev = lines[i];
+		if (prev === void 0) continue;
+		if (prev.trim() === "") continue;
+		return isConditionalLine(prev);
+	}
+	return false;
+}
+function isConditionalLine(line) {
+	return /process\.env/.test(line) || line.includes("?") || /(^|[^\w])if([^\w]|$)/.test(line);
+}
+function checkCompilationCache(podfileSource, xcodeMajor) {
+	if (podfileSource == null) return null;
+	if (xcodeMajor != null && xcodeMajor < 26) return null;
+	if (!/COMPILATION_CACHE_ENABLE_CACHING/.test(podfileSource)) return null;
+	if (/COMPILATION_CACHE_CAS_PATH/.test(podfileSource)) return null;
+	return finding("note", "The Podfile enables compilation caching but leaves the CAS at its default path", "The default CAS lives at the DerivedData root, and DerivedData is per-workspace -- so nothing is actually shared between worktrees, which is the only reason to turn it on. Builds Stim drives are unaffected: they override COMPILATION_CACHE_CAS_PATH to a shared path on the xcodebuild command line, which wins over the project setting. This costs only the builds you run outside Stim.", "Nothing to do for Stim. For builds outside it: set COMPILATION_CACHE_CAS_PATH to a fixed path outside DerivedData -- ~/.stim/compilation-cache is where Stim puts its own, so the two share entries instead of filling two caches.");
+}
+function checkCcacheConflict(podfileSource, podfileProperties) {
+	if (podfileSource == null) return null;
+	if (!ccacheEnabled(podfileProperties)) return null;
+	return finding("cost", "ccache is enabled, so Stim leaves Xcode compilation caching off", "The ccache launcher script is what disables explicitly built modules, which compilation caching requires -- so enabling both tends to mean neither works. Stim will not add its compilation-cache settings to a build whose project has apple.ccacheEnabled=true, and in its default configuration ccache hashes the working directory and every absolute include path, so it misses across worktrees. (Stim relocates ccache itself on Android, where it drives the compile and can set CCACHE_BASEDIR and CCACHE_NOHASHDIR; the Podfile launcher script here is the project's, not Stim's.)", "Pick one, and on Xcode 26 the compilation cache is the one that survives a different workspace path -- Stim supplies it on its own builds as soon as ccache is off. Turn it off where the value comes FROM: on Expo that is the expo-build-properties plugin in the app config (ios.ccacheEnabled), because prebuild rewrites ios/Podfile.properties.json from it; on a bare project edit ios/Podfile.properties.json directly. Then re-run pod install (or let `stim ios` do it).");
+}
+function checkCcacheInstalled(onPath) {
+	if (onPath) return null;
+	return finding("cost", "ccache is not on PATH, so Android C++ recompiles in every worktree", "Stim resolves the launcher with `command -v ccache` -- the same PATH lookup the build itself uses -- and found nothing, so it passes no CMAKE_C_COMPILER_LAUNCHER / CMAKE_CXX_COMPILER_LAUNCHER to Gradle and every AGP CMake task compiles without one. Those tasks are uncacheable by Gradle, so not one C++ object crosses a worktree. Measured on trailhead (arm64, fresh worktree): 49.6s without the launcher against 34.2s with it.", "brew install ccache, then delete android/app/.cxx and node_modules/**/android/.cxx once so CMake reconfigures with the launcher. The shell that runs Stim must have the install location on PATH -- agent shells often lack /opt/homebrew/bin.");
+}
+function launcherPath(launcher) {
+	const command = launcher?.split(";")[0]?.trim();
+	return command && isAbsolute$1(command) ? command : null;
+}
+function checkCxxCompilerLauncher({ states, ccacheOnPath, launcherExists = existsSync$1 }) {
+	const missing = states.map((state) => ({
+		path: state.path,
+		command: launcherPath(state.launcher)
+	})).filter((state) => state.command !== null && !launcherExists(state.command));
+	if (missing.length > 0) {
+		const named = [...new Set(missing.map((state) => state.command))].join(", ");
+		return finding("cost", "A configured CMake cache names a compiler launcher that is not on this machine", `${plural(missing.length, "CMakeCache.txt file")} under this project name ${named}, and CMake runs that path for every C++ compile. Until the cache is reconfigured the build fails there rather than falling back: ${missing[0]?.path}.`, "With ccache installed, run `stim doctor --fix --platform android` in this checkout to clear affected generated .cxx configurations. Custom launchers require project-specific repair. Stop native builds before repairing.");
+	}
+	if (!ccacheOnPath) return null;
+	const stale = states.filter((state) => state.launcher === null);
+	if (stale.length === 0) return null;
+	return finding("cost", "The configured CMake cache predates the ccache launcher, so C++ compiles still bypass it", `CMake seeds CMAKE_CXX_COMPILER_LAUNCHER from the environment on a fresh configure only. ${plural(stale.length, "CMakeCache.txt file")} here names no launcher: ${stale[0]?.path}. These configurations can bypass ccache; cache misses reported by ccache itself still represent compilations that used the launcher.`, "Stop native builds, then run `stim doctor --fix --platform android` in this checkout. It clears affected ignored, untracked .cxx configurations; the next `stim android` configures them with ccache. Existing custom launcher settings require project-specific repair.");
+}
+function ccacheIsOnPath() {
+	try {
+		return Boolean(getExecutor().runQuiet("command -v ccache", { timeoutMs: 5e3 }));
+	} catch {
+		return false;
+	}
+}
+function checkBuildCacheProvider(appConfig, sdkMajor, isExpo = true, dynamicConfig = null) {
+	if (!isExpo) return null;
+	if (!appConfig && dynamicConfig) return finding("note", `Cannot check the build cache provider in ${dynamicConfig}`, "This config is code, so it is not readable without executing it. A provider is optional -- stim ios/android have their own cache -- but if this project DOES set one, confirm by hand that it is on the key this SDK reads.", `${sdkMajor && sdkMajor <= 53 ? `SDK ${sdkMajor} reads expo.experiments.buildCacheProvider and ignores the top-level key in silence.` : "Use the top-level expo.buildCacheProvider; the experiments key still works as a fallback."} Run \`npx expo config --json\` and look for buildCacheProvider. If one is already set -- including "eas" -- that satisfies this; Stim never replaces it.`);
+	if (!appConfig) return null;
+	const expo = appConfig.expo ?? appConfig;
+	const topLevel = expo.buildCacheProvider;
+	const experimental = expo.experiments?.buildCacheProvider;
+	if (!topLevel && !experimental) return null;
+	if (sdkMajor && sdkMajor <= 53 && topLevel && !experimental) return finding("cost", "buildCacheProvider is at the top level, but this SDK only reads it from experiments", `SDK ${sdkMajor}'s CLI resolves exp.experiments.buildCacheProvider and nothing else. The top-level key is ignored in silence, so the provider is never called and every build is a full build.`, "Move it to expo.experiments.buildCacheProvider.");
+	if (sdkMajor && sdkMajor >= 54 && experimental && !topLevel) return finding("note", "buildCacheProvider is still under experiments", `It works -- SDK ${sdkMajor} falls back to the experiments key -- but the setting was promoted out of experiments, and the top-level key is the one that will keep working.`, "Move it to expo.buildCacheProvider.");
+	return null;
+}
+function checkEasAuth({ provider, owner = null, auth = null } = {}) {
+	if (provider !== "eas") return null;
+	const status = typeof auth === "function" ? auth({ owner }) : auth;
+	if (!status || status.ok) return null;
+	if (status.unknown) return finding("note", "Could not check the EAS session", `\`eas whoami\` did not give a definite answer (${status.unknown}), so whether this project's EAS build cache can be reached is unknown. Offline is the ordinary reason, and it is not a problem: the cache simply does not answer until the machine is back on the network.`, null);
+	if (status.code === "no-cli") return finding("cost", "The build cache provider is \"eas\", but no eas-cli is installed", "The provider shells out to `npx eas-cli` on every lookup and every upload. With no eas-cli resolvable, npx downloads one on the fly (slow, and a version nobody chose) or the call fails -- and the provider swallows that failure and returns null, so every build looks like a cache miss and nothing says why.", status.remedy ?? null);
+	if (status.code === "logged-out") return finding("cost", "Not logged in to EAS, so the shared build cache never answers", "eas-build-cache-provider catches its own errors and returns null, so an unauthenticated lookup reads as a plain cache miss: every build compiles, nothing is uploaded for anybody else, and no line in any log mentions authentication.", status.remedy ?? null);
+	if (status.code === "wrong-account") return finding("note", `EAS is authenticated as ${status.account}, but this project's owner is ${status.owner}`, `A session on an account that does not cover ${status.owner} cannot read or write that account's builds, so the shared cache silently does nothing here. This is a NOTE and not a hard failure on purpose: \`eas whoami\` only enumerates accounts for some actors (a robot prints a display name that is not an account name at all), the list may be incomplete, and access is the server's decision rather than this list's. Confirm before acting on it.`, status.remedy ?? null);
+	return null;
+}
+function checkConcurrency({ maxBuilds = 0, maxDevices = 0, liveDevices = 0, activeBuilds = 0 } = {}) {
+	if (!maxBuilds && !maxDevices) return null;
+	return finding("note", "Concurrency limits are set", `${`maxBuilds ${maxBuilds || "unlimited"}, maxDevices ${maxDevices || "unlimited"}`}. Right now ${liveDevices} Stim device(s) are booted and ${activeBuilds} build slot(s) are in use on this machine. At the device cap a new \`stim ios\`/\`android\` is refused with STIM_AT_CAPACITY (stop an environment or raise it); at the build cap a compile waits for a free slot.`, null);
+}
+function checkRemoteDevice({ configured = null, daemonInEnv = false, agentDeviceOnPath = false, easCliResolvable = false } = {}) {
+	if (!configured) return null;
+	if (!agentDeviceOnPath) return finding("cost", "A remote device is configured, but agent-device is missing", `agent-device drives the selected remote backend. Without it, \`stim ios --remote ${configured}\` and \`stim android --remote ${configured}\` refuse before device work.`, "npm i -g agent-device");
+	if (configured === "proxy") {
+		if (daemonInEnv) return finding("note", "This project uses a remote proxy", "The proxy backend connects through AGENT_DEVICE_DAEMON_BASE_URL and AGENT_DEVICE_DAEMON_AUTH_TOKEN. Stim does not create or stop the remote device.", null);
+		return finding("cost", "The remote proxy credentials are missing", "The proxy backend requires AGENT_DEVICE_DAEMON_BASE_URL and AGENT_DEVICE_DAEMON_AUTH_TOKEN.", "Export AGENT_DEVICE_DAEMON_BASE_URL and AGENT_DEVICE_DAEMON_AUTH_TOKEN.");
+	}
+	if (!easCliResolvable) return finding("cost", "A remote device is configured, but there is no eas-cli to create a session with", "The eas backend creates an EAS Simulator session. It needs eas-cli and an account with EAS Simulator access. Neither a project copy nor one on PATH was found.", "Install eas-cli.");
+	return finding("note", "This project uses a remote device", "`ios --remote eas` / `android --remote eas` create an EAS Simulator session named stim-<label> and end it on `stop` and `worktree remove`. The build still runs on this machine; only the device is elsewhere. Native device logs are not captured on a remote device -- the Metro half of the timeline is unaffected.", null);
+}
+function checkSimSlim({ configured = false, profileError = null, onPath = false } = {}) {
+	if (profileError) return finding("cost", "The SimSlim profile is invalid", profileError, "Set ios.simslimProfile to a readable JSON profile inside the repository.");
+	if (!configured) return finding("note", "SimSlim is recommended for parallel iOS simulator work", "A reviewed profile can reduce background simulator services and memory use. It is optional: disabling services can affect tests that depend on them, and installing the binary alone does not apply a profile.", "Run `stim guide lifecycle simslim` to install SimSlim and configure ios.simslimProfile. Stim does not enable a profile through doctor --fix.");
+	if (onPath) return null;
+	return finding("cost", "A SimSlim profile is configured, but SimSlim is not installed", "`stim ios` needs the `simslim` command to apply the profile to its owned simulator.", "brew install mobai-app/tap/simslim");
+}
+function runDoctor(projectRoot, { readFile = readFileSync$1, xcodeMajor = null, easAuth = checkEasAuth$1, concurrency = getConcurrencyLimits, liveDevices = null, activeBuilds = null, remoteEnv = process.env, lookupAgentDevice = null, lookupEasCli = null, lookupSimSlim = null, memoryPressure = readHostMemoryPressure, lookupCcache = null, platform } = {}) {
+	const read = (rel) => {
+		const p = join$1(projectRoot, rel);
+		if (!existsSync$1(p)) return null;
+		try {
+			return readFile(p, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+	const settingsRepoRoot = repoRoot(projectRoot) ?? projectRoot;
+	const machineSettings = readMachineSettings({
+		projectPath: projectRoot,
+		gitCommonDir: gitCommonDir(projectRoot),
+		repoRoot: settingsRepoRoot
+	});
+	if (machineSettings.corrupt) return [machineSettings.corrupt];
+	const projectSettings = machineSettings.settings;
+	const pkg = readJson(join$1(projectRoot, "package.json"));
+	const appConfig = readJson(join$1(projectRoot, "app.json"));
+	const dynamicConfig = appConfig ? null : [
+		"app.config.ts",
+		"app.config.js",
+		"app.config.mjs"
+	].find((f) => existsSync$1(join$1(projectRoot, f))) || null;
+	const podfileProperties = readJson(join$1(projectRoot, "ios", "Podfile.properties.json"));
+	const podfile = read(join$1("ios", "Podfile"));
+	const metroConfig = read("metro.config.js") ?? read("metro.config.cjs");
+	const isExpo = detectIsExpo(projectRoot);
+	const expoRange = (pkg?.dependencies)?.expo || "";
+	const sdkMajor = parseInt(String(expoRange).replace(/[^\d.]/g, "").split(".")[0] ?? "", 10) || null;
+	const provider = appConfig ? providerFromConfig(appConfig) : null;
+	const owner = appConfig ? ownerFromConfig(appConfig) : null;
+	const limits = typeof concurrency === "function" ? concurrency() : concurrency;
+	let concurrencyFinding = null;
+	if (limits && (limits.maxBuilds || limits.maxDevices)) concurrencyFinding = checkConcurrency({
+		maxBuilds: limits.maxBuilds,
+		maxDevices: limits.maxDevices,
+		liveDevices: liveDevices ? liveDevices() : countLiveDevices(),
+		activeBuilds: activeBuilds ? activeBuilds() : countActiveBuilds()
+	});
+	const settingShapeFindings = settingShapeErrors(projectSettings).map((error) => finding("cost", "A setting has the wrong type", error, SETTING_SHAPE_REMEDY));
+	let optimizations = null;
+	try {
+		optimizations = resolveAndroidCompilerCache({
+			optimizations: resolveOptimizations(projectSettings),
+			use: readAndroidCasToolchain
+		}).optimizations;
+	} catch (error) {
+		settingShapeFindings.push(finding("cost", "Invalid optimization setting", error.message, SETTING_SHAPE_REMEDY));
+	}
+	const remoteBuildCache = optimizations?.buildCache && optimizations.remoteBuildCache;
+	const easFinding = remoteBuildCache && provider === "eas" ? checkEasAuth({
+		provider,
+		owner,
+		auth: easAuth({
+			projectRoot,
+			owner
+		})
+	}) : null;
+	for (const poolPlatform of ["ios", "android"]) {
+		if (platform && platform !== poolPlatform) continue;
+		const poolSettingError = parkedMaxSetting(poolPlatform).error;
+		if (poolSettingError) settingShapeFindings.push(finding("cost", `The ${poolPlatform === "ios" ? "simulator" : "emulator"} pool bound is not a number`, poolSettingError, POOL_SETTING_REMEDY));
+	}
+	let simslimProfile = null;
+	let simslimProfileError = null;
+	if (platform !== "android") try {
+		simslimProfile = iosSimSlimProfileSetting(projectSettings, projectRoot);
+	} catch (error) {
+		simslimProfileError = String(error?.message || error);
+	}
+	const simslimFinding = platform === "android" || !simslimProfile && !simslimProfileError && remoteIosSetting(projectSettings) ? null : checkSimSlim({
+		configured: Boolean(simslimProfile),
+		profileError: simslimProfileError,
+		onPath: simslimProfile ? lookupSimSlim ? lookupSimSlim() : simslimIsOnPath() : false
+	});
+	const remoteBackends = [.../* @__PURE__ */ new Set([...platform !== "android" ? [remoteIosSetting(projectSettings)] : [], ...platform !== "ios" ? [remoteAndroidSetting(projectSettings)] : []])].filter((backend) => backend !== null);
+	const daemonInEnv = Boolean(remoteEnv.AGENT_DEVICE_DAEMON_BASE_URL?.trim() && remoteEnv.AGENT_DEVICE_DAEMON_AUTH_TOKEN?.trim());
+	const agentDeviceOnPath = remoteBackends.length ? lookupAgentDevice ? lookupAgentDevice() : agentDeviceIsOnPath() : false;
+	const easCliResolvable = remoteBackends.includes("eas") ? lookupEasCli ? lookupEasCli() : Boolean(resolveEasCliBin(projectRoot)) : false;
+	const remoteFindings = remoteBackends.map((backend) => checkRemoteDevice({
+		configured: backend,
+		daemonInEnv,
+		agentDeviceOnPath,
+		easCliResolvable
+	})).filter((remoteFinding) => remoteFinding !== null);
+	const memoryAdvice = platform !== "android" && !remoteIosSetting(projectSettings) ? hostMemoryPressureAdvice(memoryPressure()) : null;
+	return [
+		checkAppProject(projectRoot),
+		...checkMainCheckout(projectRoot, { platform }),
+		...platform === "android" ? [] : inspectIosDebugArchitectures(mainCheckoutProjectRoot(projectRoot)),
+		...checkStorageLayout(projectRoot, { platform }),
+		optimizations?.metroSharedCache ? checkMetroCache(metroConfig) : null,
+		platform === "android" || !optimizations?.ios.compilationCache ? null : checkCompilationCache(podfile, xcodeMajor),
+		platform === "android" || !optimizations?.ios.compilationCache ? null : checkCcacheConflict(podfile, podfileProperties),
+		...platform === "ios" || optimizations?.android.compilerCache !== "ccache" ? [] : androidCcacheFindings(projectRoot, platform, lookupCcache),
+		remoteBuildCache ? checkBuildCacheProvider(appConfig, sdkMajor, isExpo, dynamicConfig) : null,
+		easFinding,
+		concurrencyFinding,
+		memoryAdvice ? finding("cost", "Host memory pressure can stall the iOS simulator", memoryAdvice, "Free host memory, then retry. Run `stim guide lifecycle simslim` for the optional memory reduction setup.") : null,
+		simslimFinding,
+		...remoteFindings,
+		...settingShapeFindings,
+		...checkMachineSettings({
+			settings: projectSettings,
+			layers: machineSettings.layers,
+			projectRoot,
+			optimizations,
+			reportedElsewhere: simslimProfileError ? ["ios.simslimProfile"] : []
+		})
+	].filter((f) => Boolean(f));
+}
+function androidCcacheFindings(projectRoot, platform, lookupCcache) {
+	if (platform !== "android" && !existsSync$1(join$1(projectRoot, "android"))) return [];
+	const onPath = lookupCcache ? lookupCcache() : ccacheIsOnPath();
+	let cxx;
+	try {
+		cxx = checkCxxCompilerLauncher({
+			states: readCxxLauncherStates(projectRoot),
+			ccacheOnPath: onPath
+		});
+	} catch (error) {
+		cxx = finding("cost", "CMake launcher state could not be inspected", String(error), "Restore read access and rerun doctor.");
+	}
+	if (cxx) cxx.code = "android-cmake-launcher";
+	return [checkCcacheInstalled(onPath), cxx];
+}
+function checkAppProject(projectRoot) {
+	const problem = appProjectProblem(projectRoot);
+	if (!problem) return null;
+	return finding("cost", problem.kind === "unreadable" ? "This package.json does not parse" : "This directory is not a React Native or Expo app", `${problem.message} \`stim start\`, \`stim ios\` and \`stim android\` refuse here with STIM_NO_PROJECT, so nothing below was measured against an app.`, problem.remedy);
+}
+function agentDeviceIsOnPath() {
+	try {
+		return Boolean(getExecutor().runQuiet("command -v agent-device", { timeoutMs: 5e3 }));
+	} catch {
+		return true;
+	}
+}
+function countLiveDevices() {
+	let sims = [];
+	let adb = {
+		emulators: [],
+		physical: [],
+		unhealthy: []
+	};
+	let config = null;
+	try {
+		sims = listAllIosSims() || [];
+	} catch {}
+	try {
+		adb = listAdbDevices() || adb;
+	} catch {}
+	try {
+		config = loadConfig();
+	} catch {}
+	return liveOwnedDeviceCount({
+		sims,
+		adbEmulators: adb.emulators || [],
+		config
+	});
+}
+function countActiveBuilds() {
+	try {
+		return listBuildSlots().filter((s) => s.alive).length;
+	} catch {
+		return 0;
+	}
+}
+function checkFingerprintParity({ projectHash, worktreeHash, changed = [], dirtyFiles = [] } = {}) {
+	if (!projectHash || !worktreeHash || projectHash === worktreeHash) return null;
+	const names = changed.slice(0, 3).join(", ");
+	return finding("note", "This checkout does not fingerprint like a fresh worktree of HEAD", `A clean detached worktree of HEAD computes a different @expo/fingerprint hash than this checkout, so worktrees will MISS the cache entries this checkout fills (and vice versa) until the two agree.${changed.length ? ` The differing source${changed.length === 1 ? "" : "s"}: ${names}${changed.length > 3 ? ` (and ${changed.length - 3} more)` : ""}.` : ""} ${dirtyFiles.length ? `The likely cause is uncommitted changes to tracked fingerprint inputs -- git reports ${dirtyFiles.slice(0, 3).join(", ")}${dirtyFiles.length > 3 ? ` (and ${dirtyFiles.length - 3} more)` : ""} dirty in this checkout.` : "The likely cause is uncommitted changes to tracked fingerprint inputs (this check compared against a clean worktree of HEAD)."} (To measure this, doctor ran a real fingerprint twice and briefly created a temporary git worktree -- .git/worktrees metadata was touched and cleaned up.)`, "Commit the dirty fingerprint inputs, or list the build-irrelevant ones in .fingerprintignore (same syntax as .gitignore, at the project root; Stim already ignores android/local.properties and android/.idea). Only the ones that genuinely cannot change the native build belong there -- generated reports, local env files, a lockfile whose checksums embed absolute machine paths. Never ignore a real native input (a Podfile, a gradle file, the app config) to force a hit: that trades a slow build for a wrong one.");
+}
+function gitMetadataAt(path) {
+	try {
+		const git = lstatSync$1(join$1(path, ".git"));
+		return git.isFile() || git.isDirectory();
+	} catch {
+		return false;
+	}
+}
+function listDirectory(dir) {
+	try {
+		return readdirSync$1(dir);
+	} catch {
+		return [];
+	}
+}
+function hasLinkedPackageWithGit(projectRoot) {
+	const root = repoRoot(projectRoot) ?? projectRoot;
+	for (let dir = projectRoot;; dir = dirname$1(dir)) {
+		if (linkedPackageWithGitIn(join$1(dir, "node_modules"))) return true;
+		if (dir === root || dirname$1(dir) === dir || relative$1(root, dirname$1(dir)).startsWith("..")) return false;
+	}
+}
+function linkedPackageWithGitIn(nodeModules) {
+	return listDirectory(nodeModules).filter((entry) => !entry.startsWith(".")).flatMap((entry) => entry.startsWith("@") ? listDirectory(join$1(nodeModules, entry)).map((child) => join$1(entry, child)) : [entry]).some((name) => {
+		const root = join$1(nodeModules, name);
+		try {
+			return lstatSync$1(root).isSymbolicLink() && gitMetadataAt(root);
+		} catch {
+			return false;
+		}
+	});
+}
+/**
+* A linked native library (a `link:` or `file:` dependency, or a workspace
+* symlink) brings its checkout's Git metadata into a directory the fingerprint
+* hashes whole. That metadata changes with every Git operation in the linked
+* checkout, so workspaces rarely hash alike even when the library's native
+* sources match. The fingerprint's own debug output says which directories
+* still hash a .git entry, whatever ignore mechanism the project uses. Linked
+* packages can be hoisted, so the gate looks at every node_modules from the
+* app up to the repository root.
+*/
+async function detectLinkedLibraryGitMetadata(projectRoot, { createFingerprint = expoFingerprint.createFingerprintAsync, platform } = {}) {
+	const mainRoot = mainCheckoutProjectRoot(projectRoot);
+	if (!hasLinkedPackageWithGit(mainRoot)) return null;
+	let sources;
+	try {
+		sources = (await fingerprintProject(mainRoot, {
+			platform,
+			createFingerprint,
+			debug: true
+		}))?.sources ?? [];
+	} catch {
+		return null;
+	}
+	const directories = sources.flatMap((source) => {
+		if (source.type !== "dir" || typeof source.filePath !== "string") return [];
+		return (source.debugInfo?.children ?? []).some((child) => child?.path === `${source.filePath}/.git`) ? [source.filePath] : [];
+	});
+	if (!directories.length) return null;
+	const several = directories.length > 1;
+	const entries = directories.flatMap((dir) => [`${dir}/.git`, `${dir}/.git/**/*`]);
+	return {
+		...finding("note", `${several ? `${directories.length} linked native libraries carry` : "A linked native library carries"} Git metadata into the fingerprint`, `${directories.map((dir) => `${dir}/.git`).join(", ")} ${several ? "are" : "is"} inside a directory the fingerprint hashes whole. Git rewrites that metadata on every commit, checkout, or worktree of the linked checkout (a worktree turns a .git directory into a pointer file), so this workspace and its worktrees rarely compute the same fingerprint even when the library's native sources match, and each one compiles instead of reusing the artifact.`, `When the native build does not read that Git state, add ${entries.map((entry) => `\`${entry}\``).join(", ")} to .fingerprintignore at the project root: the first form matches the pointer file a worktree has, the second excludes a .git directory's contents. Ignore only the .git entry, not the package: its native sources still have to move the key.`),
+		code: "linked-library-git-metadata"
+	};
+}
+async function detectFingerprintParity(projectRoot, { createFingerprint = expoFingerprint.createFingerprintAsync, differ = expoFingerprint.diffFingerprints, dirtyFiles = dirtyFingerprintFiles, platform: selectedPlatform } = {}) {
+	const exec = getExecutor();
+	if (exec.runFileQuiet("git", [
+		"-C",
+		projectRoot,
+		"rev-parse",
+		"--git-dir"
+	], { timeoutMs: 1e4 }) == null) return null;
+	if (hasInstalledDependencies(projectRoot)) return null;
+	const platform = selectedPlatform ?? (existsSync$1(join$1(projectRoot, "ios")) ? "ios" : existsSync$1(join$1(projectRoot, "android")) ? "android" : void 0);
+	let base;
+	try {
+		base = makeTemporaryDirectory(projectRoot, "stim-parity-");
+	} catch {
+		return null;
+	}
+	const worktree = join$1(base, "head");
+	if (exec.runFileQuiet("git", [
+		"-C",
+		projectRoot,
+		"worktree",
+		"add",
+		"--detach",
+		worktree,
+		"HEAD"
+	], { timeoutMs: 6e4 }) == null) {
+		rmSync$1(base, {
+			recursive: true,
+			force: true
+		});
+		return null;
+	}
+	try {
+		const project = await fingerprintProject(projectRoot, {
+			platform,
+			createFingerprint
+		});
+		const clean = await fingerprintProject(worktree, {
+			platform,
+			createFingerprint
+		});
+		if (!project || !clean) return null;
+		if (project.hash === clean.hash) return null;
+		const changed = diffFingerprintSources({
+			previous: clean.sources,
+			previousHash: clean.hash,
+			current: project,
+			differ
+		});
+		return checkFingerprintParity({
+			projectHash: project.hash,
+			worktreeHash: clean.hash,
+			changed,
+			dirtyFiles: dirtyFiles(projectRoot)
+		});
+	} catch {
+		return null;
+	} finally {
+		exec.runFileQuiet("git", [
+			"-C",
+			projectRoot,
+			"worktree",
+			"remove",
+			"--force",
+			worktree
+		], { timeoutMs: 3e4 });
+		rmSync$1(base, {
+			recursive: true,
+			force: true
+		});
+		exec.runFileQuiet("git", [
+			"-C",
+			projectRoot,
+			"worktree",
+			"prune"
+		], { timeoutMs: 1e4 });
+	}
+}
+//#endregion
+export { installedNpmTreeIsValid as a, repairCxxLauncherState as c, hasInstalledDependencies as i, detectFingerprintParity as n, locallyKnownUpstream as o, detectLinkedLibraryGitMetadata as r, runDoctor as s, dependencyState as t };