stim 1.20.2 → 1.22.0

package/dist/{gradle-DSrXb6lG.mjs → react-native-build-Dvd8hC21.mjs}

@@ -1,15 +1,73 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
+import { d as spawnDeclared, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { o as sharedCompilationCache } from "./paths-DQtTgsBf.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { o as androidHome } from "./android-Mz_Inn3w.mjs";
-import { a as spawnDeclared } from "./spawn-claims-DVS5RkMS.mjs";
-import { a as readCcacheActivity, n as CCACHE_UNAVAILABLE } from "./ccache-zdKiYQ3E.mjs";
-import { M as startBuildHeartbeat, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DxSsNssu.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { a as killOnAbort } from "./operation-exec-BW0em61G.mjs";
+import { C as resolvePackageJson } from "./project-wM_XFTvE.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { o as androidHome } from "./android-C7sVmyI9.mjs";
+import { p as resolveOptimizations } from "./errors-ccaPc4ox.mjs";
+import { a as readCcacheActivity, n as CCACHE_UNAVAILABLE } from "./ccache-Btwc36-I.mjs";
+import { a as buildXcode, d as pickXcodeProject, g as swiftPrefixMappingSupported, h as startBuildHeartbeat, i as SWIFT_PREFIX_MAPPING_MIN_SWIFT, l as parseSwiftVersion, r as HEARTBEAT_INTERVAL_MS, s as compilationCacheSettings, u as parseXcodeMajor } from "./xcode-BXn9-xYx.mjs";
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { ambientContext } from "@stim-cli/core";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import chalk from "chalk";
+//#region src/engine/android-path-limit.ts
+/**
+* CMake's single-config Ninja generator measures an object against CMAKE_OBJECT_PATH_MAX from
+* `<target>.dir/./`, two characters longer than the directory the object is written to, so a
+* shortened object path fits only up to this length.
+* https://github.com/Kitware/CMake/blob/v3.22.1/Source/cmGlobalNinjaGenerator.cxx#L1005-L1013
+*/
+const LONGEST_SHORTENED_OBJECT_PATH = 238;
+/**
+* `\android\app\.cxx\<4 hex>\Debug\<8 chars>\<abi>\safeareacontext_autolinked_build/CMakeFiles/react_codegen_safeareacontext.dir/<md5>/RNCSafeAreaViewShadowNode.cpp.o`,
+* measured on the bare e2e fixture and on trailhead (Expo SDK 58, RN 0.88).
+*/
+const SAFE_AREA_CONTEXT_OBJECT = {
+	target: "react_codegen_safeareacontext",
+	tail: 181
+};
+/**
+* react-native-gesture-handler 3 compiles shadow nodes from its `shared/shadowNodes` directory into
+* its codegen library:
+* `\android\app\.cxx\<4 hex>\Debug\<8 chars>\<abi>\rngesturehandler_codegen_autolinked_build/CMakeFiles/react_codegen_rngesturehandler_codegen.dir/<md5>/RNGestureHandlerDetectorShadowNode.cpp.o`,
+* measured on trailhead. https://github.com/appandflow/stim/issues/3641
+*/
+const GESTURE_HANDLER_OBJECT = {
+	target: "react_codegen_rngesturehandler_codegen",
+	tail: 208
+};
+function longestAndroidObject(root) {
+	const gestureHandler = resolvePackageJson(root, "react-native-gesture-handler");
+	return gestureHandler && existsSync(join(dirname(gestureHandler), "shared", "shadowNodes")) ? GESTURE_HANDLER_OBJECT : SAFE_AREA_CONTEXT_OBJECT;
+}
+/** The ABI name a build for every ABI has to fit; `stim android` narrows a build to the device's. */
+const LONGEST_ANDROID_ABI = "armeabi-v7a";
+function androidPathRoom(root, { abi = null, variant = null, platform = process.platform, object = null } = {}) {
+	if (platform !== "win32") return null;
+	const { target, tail: objectTail } = object ?? longestAndroidObject(root);
+	const abiName = abi ?? LONGEST_ANDROID_ABI;
+	const tail = objectTail + (/release$/i.test(variant ?? "") ? 14 : 5) - 5 + abiName.length;
+	const longest = root.length + tail;
+	if (longest <= LONGEST_SHORTENED_OBJECT_PATH) return null;
+	return {
+		root,
+		abi: abiName,
+		target,
+		longest,
+		maxRootLength: LONGEST_SHORTENED_OBJECT_PATH - tail
+	};
+}
+function androidPathRoomMessage({ root, abi, target, longest, maxRootLength }) {
+	return `The project root ${root} is ${root.length} characters, so the longest known Android native object path (${target} for ${abi}) reaches ${longest} characters, past the ${LONGEST_SHORTENED_OBJECT_PATH} CMake can shorten it to for the NDK's ninja on Windows; the root can be at most ${maxRootLength} characters.`;
+}
+function androidPathRoomRemedy({ maxRootLength }) {
+	return `Move or clone the project to a real path of at most ${maxRootLength} characters, such as C:\\src\\<name>, and run Stim there. A subst drive does not help: Node and Expo autolinking resolve it back to the long path.`;
+}
 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*(.*)$/;
@@ -31,7 +89,7 @@ const BUILD_TAIL = /^(?:BUILD (?:FAILED|SUCCESSFUL) in\b|Deprecated Gradle featu
 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."],
+	[/SDK location not found|ANDROID_HOME|ANDROID_SDK_ROOT|sdk\.dir/i, "Set ANDROID_HOME to the Android SDK (usually ~/Library/Android/sdk on macOS, ~/Android/Sdk on Linux), 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)`)."],
@@ -275,7 +333,7 @@ function androidSdkRefusal({ sdkPath, sdkExists, hasLocalProperties, localProper
 	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 ${localPropertiesPath}. JAVA_HOME must point at a JDK 17 install as well.`
+		remedy: `Set ANDROID_HOME to the Android SDK (Android Studio installs it at ~/Library/Android/sdk on macOS and ~/Android/Sdk on Linux), or write sdk.dir into ${localPropertiesPath}. JAVA_HOME must point at a JDK 17 install as well.`
 	};
 }
 function pickDebugApk(files) {
@@ -311,7 +369,7 @@ 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"));
+	const metadata = readOrNull$1(join(dir, "output-metadata.json"));
 	if (metadata) {
 		const named = parseOutputMetadata(metadata);
 		if (named) {
@@ -539,7 +597,7 @@ function gradleArgs(task, { buildCache = true, projectArgs = [] } = {}) {
 		...projectArgs
 	];
 }
-async function buildGradle({ root, logWriter, variant = null, project, task, projectArgs = [], preflightFailure = null, locate }, { 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) } = {}) {
+async function buildGradle({ root, logWriter, variant = null, project, task, projectArgs = [], preflightFailure = null, locate }, { spawnFn = null, now = Date.now, env = ambientContext()?.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 sdk = androidHome(env);
 	const sdkExists = existsSync(sdk);
 	const refusal = androidSdkRefusal({
@@ -623,7 +681,7 @@ async function buildGradle({ root, logWriter, variant = null, project, task, pro
 	if (ccache) resetStatsLog(ccache.statsLog);
 	let child;
 	try {
-		child = spawnDeclared(() => spawn(project.gradlew, args, {
+		child = spawnDeclared(ambientContext(), () => spawn(project.gradlew, args, {
 			cwd: project.directory,
 			stdio: [
 				"ignore",
@@ -639,7 +697,7 @@ async function buildGradle({ root, logWriter, variant = null, project, task, pro
 				TERM: "dumb",
 				FORCE_COLOR: "0"
 			}
-		}));
+		}), { until: process.platform === "win32" ? "close" : "exit" });
 	} catch (err) {
 		return spawnFailure(err, root, project, now() - startedAt);
 	}
@@ -655,7 +713,9 @@ async function buildGradle({ root, logWriter, variant = null, project, task, pro
 		emit: onHeartbeat,
 		estimateMs
 	});
+	const closed = process.platform === "win32" ? new Promise((resolve) => child.once("close", () => resolve())) : void 0;
 	const result = await waitForChild(child);
+	await closed;
 	stopHeartbeat();
 	outReader.flush();
 	errReader.flush();
@@ -755,7 +815,7 @@ function safeList(dir) {
 		return [];
 	}
 }
-function readOrNull(file) {
+function readOrNull$1(file) {
 	try {
 		return readFileSync(file, "utf-8");
 	} catch {
@@ -763,4 +823,221 @@ function readOrNull(file) {
 	}
 }
 //#endregion
-export { buildGradle as a, formatDiagnostic as c, assembleTaskFor as i, BUILD_ERROR as n, parseProductFlavors as o, androidSdkRefusal as r, variantNameOf as s, ASSEMBLE_TASK as t };
+//#region src/integrations/react-native-build.ts
+function gradlewPath(layout) {
+	return join(layout.gradleRoot, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+}
+function apkOutputsDir(layout) {
+	return join(layout.moduleDir, "build", "outputs", "apk");
+}
+function discoverAndroidProject(root, layout) {
+	const dir = layout.gradleRoot;
+	if (!existsSync(dir)) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `No ${relative(root, dir) || "."}/ 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(layout);
+	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 ${relative(root, dir) || "."}/, or regenerate the project with \`npx expo prebuild -p android --clean\`).`
+	};
+	return {
+		androidDir: dir,
+		gradlew
+	};
+}
+function readProductFlavors(layout) {
+	return parseProductFlavors(readOrNull(join(layout.moduleDir, "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 readOrNull(path) {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function buildAndroid({ root, layout, logWriter, variant = null, abi = null }, options = {}) {
+	const project = discoverAndroidProject(root, layout);
+	if (project.failed) return {
+		ok: false,
+		code: project.code,
+		reason: project.reason,
+		remedy: project.remedy,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: [],
+		durationMs: 0
+	};
+	const room = androidPathRoom(root, {
+		abi,
+		variant,
+		platform: options.platform ?? process.platform
+	});
+	return buildGradle({
+		root,
+		logWriter,
+		variant,
+		project: {
+			directory: project.androidDir,
+			gradlew: project.gradlew,
+			module: layout.module,
+			outputsDir: apkOutputsDir(layout)
+		},
+		task: layout.custom ? `${layout.module}:${assembleTaskFor(variant)}` : assembleTaskFor(variant),
+		projectArgs: abi ? [`-PreactNativeArchitectures=${abi}`] : [],
+		preflightFailure: room ? {
+			code: "STIM_PATH_TOO_LONG",
+			reason: androidPathRoomMessage(room),
+			remedy: androidPathRoomRemedy(room)
+		} : null
+	}, options);
+}
+const PREBUILD_REMEDY = "Generate it with `npx expo prebuild -p ios` (stim ios does this automatically for an Expo project with no ios/ directory), or commit the native project.";
+function buildFailure(message, remedy) {
+	return { error: {
+		code: "STIM_BUILD_FAILED",
+		message,
+		remedy
+	} };
+}
+function discoverXcodeProject(root, dir) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return buildFailure(`No ${relative(root, dir) || "."}/ directory in ${root}.`, PREBUILD_REMEDY);
+	}
+	const picked = pickXcodeProject(entries);
+	if (!picked) return buildFailure(`${dir} contains no .xcworkspace and no .xcodeproj.`, PREBUILD_REMEDY);
+	return {
+		...picked,
+		dir,
+		appRoot: root,
+		path: join(dir, picked.file)
+	};
+}
+function ccacheEnabled(podfileProperties) {
+	if (!podfileProperties || typeof podfileProperties !== "object") return false;
+	return podfileProperties["apple.ccacheEnabled"] === "true";
+}
+function readPodfileProperties(iosDir) {
+	try {
+		const parsed = JSON.parse(readFileSync(join(iosDir, "Podfile.properties.json"), "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const SWIFT_CACHE_MIN_REACT_NATIVE = {
+	major: 0,
+	minor: 87
+};
+function reactNativeSupportsSwiftCache(version) {
+	if (!version) return false;
+	const min = SWIFT_CACHE_MIN_REACT_NATIVE;
+	return version.major > min.major || version.major === min.major && version.minor >= min.minor;
+}
+function parseReactNativeVersion(packageJson) {
+	if (!packageJson || typeof packageJson !== "object") return null;
+	const raw = packageJson.version;
+	const m = typeof raw === "string" ? /^(\d+)\.(\d+)\./.exec(raw) : null;
+	if (!m || m[1] === void 0 || m[2] === void 0) return null;
+	return {
+		major: parseInt(m[1], 10),
+		minor: parseInt(m[2], 10)
+	};
+}
+function detectReactNativeVersion(root) {
+	const file = resolvePackageJson(root, "react-native");
+	if (!file) return null;
+	try {
+		return parseReactNativeVersion(JSON.parse(readFileSync(file, "utf-8")));
+	} catch {
+		return null;
+	}
+}
+function reactNativeCompilationCacheSettings({ reactNativeVersion = null, ...options }) {
+	return compilationCacheSettings({
+		...options,
+		swiftCacheCompatible: reactNativeSupportsSwiftCache(reactNativeVersion)
+	});
+}
+async function resolveCompilationCacheSettings({ context, root, iosDir, derivedDataPath, exec = null, casPath = sharedCompilationCache(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
+	const executor = exec ?? getExecutor();
+	context?.signal.throwIfAborted();
+	const probeOptions = {
+		timeoutMs: 1e4,
+		declareFor: context,
+		onSpawn: killOnAbort(context?.signal)
+	};
+	const xcodeMajor = parseXcodeMajor(await executor.runFileQuietAsync("xcodebuild", ["-version"], probeOptions));
+	context?.signal.throwIfAborted();
+	const ccache = ccacheEnabled(readPodfileProperties(iosDir));
+	const probe = xcodeMajor !== null && xcodeMajor >= 26 && !ccache && optimizations.compilationCache && optimizations.swiftCompilationCache !== false;
+	const swiftVersion = probe ? parseSwiftVersion(await executor.runFileQuietAsync("xcrun", ["swift", "--version"], probeOptions)) : null;
+	context?.signal.throwIfAborted();
+	const reactNativeVersion = probe ? detectReactNativeVersion(root) : null;
+	const settings = reactNativeCompilationCacheSettings({
+		workspaceRoot: root,
+		derivedDataPath,
+		casPath,
+		xcodeMajor,
+		swiftVersion,
+		reactNativeVersion,
+		ccache,
+		optimizations
+	});
+	if (settings.length > 0 && optimizations.compilationCache) {
+		register({
+			dir: casPath,
+			registeredBy: context?.cwd ?? root,
+			name: "Xcode compilation cache",
+			prune: "atomic",
+			note: "shared Xcode compilation cache"
+		});
+		const swift = settings.includes("SWIFT_ENABLE_COMPILE_CACHE=YES") ? settings.includes("SWIFT_ENABLE_PREFIX_MAPPING=YES") ? "Swift on" : "Swift on, unmapped" : swiftVersion && !swiftPrefixMappingSupported(swiftVersion) ? `Swift off, ${swiftVersion.major}.${swiftVersion.minor} < ${SWIFT_PREFIX_MAPPING_MIN_SWIFT.major}.${SWIFT_PREFIX_MAPPING_MIN_SWIFT.minor}` : swiftVersion && reactNativeVersion && !reactNativeSupportsSwiftCache(reactNativeVersion) ? `Swift off, react-native ${reactNativeVersion.major}.${reactNativeVersion.minor} < ${SWIFT_CACHE_MIN_REACT_NATIVE.major}.${SWIFT_CACHE_MIN_REACT_NATIVE.minor}` : "Swift off";
+		onNote(chalk.dim(phaseLine("cache", `compilation cache on (CAS at ${casPath}, ${swift})`)));
+	}
+	return settings;
+}
+async function buildIos(inputs) {
+	const { root, iosDir, logWriter, udid, destination, now = () => Date.now() } = inputs;
+	if (!root || typeof root !== "string") throw new TypeError("buildIos requires {root}");
+	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildIos requires {logWriter} with a write() method");
+	if (!udid && !destination) throw new TypeError("buildIos requires {udid} (or an explicit {destination})");
+	const startedAt = now();
+	return buildXcode({
+		...inputs,
+		startedAt,
+		project: inputs.project ?? discoverXcodeProject(root, iosDir),
+		compilationCache: inputs.compilationCache === void 0 ? ({ derivedDataPath, exec }) => resolveCompilationCacheSettings({
+			context: inputs.context,
+			root,
+			iosDir,
+			derivedDataPath,
+			exec,
+			optimizations: inputs.optimizations,
+			onNote: inputs.onNote
+		}) : inputs.compilationCache
+	});
+}
+//#endregion
+export { discoverXcodeProject as a, readProductFlavors as c, buildGradle as d, formatDiagnostic as f, androidPathRoomRemedy as h, ccacheEnabled as i, androidSdkRefusal as l, androidPathRoomMessage as m, buildAndroid as n, gradlewPath as o, androidPathRoom as p, buildIos as r, productFlavorRefusal as s, apkOutputsDir as t, assembleTaskFor as u };

package/dist/react-native-doctor-DsoSF1Y9.mjs

@@ -0,0 +1,234 @@
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { K as resolveIosProjectDir, W as resolveAndroidLayout } from "./settings-C7O8A6ZI.mjs";
+import { v as detectIsExpo } from "./project-wM_XFTvE.mjs";
+import { b as bundlerPin } from "./xcode-BXn9-xYx.mjs";
+import { a as iosToolchainAsync, n as androidToolchain, r as androidToolchainAsync, t as androidRequirements } from "./toolchain-DpJMHq0n.mjs";
+import { a as reactNativeDoctorFindings, i as mainCheckoutProjectRoot, n as detectFingerprintParity, r as detectLinkedLibraryGitMetadata, s as repairCxxLauncherState, t as checkMainCheckout } from "./doctor-Bo7BXLux.mjs";
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+//#region src/diagnostics/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
+	};
+}
+async function inspectIosDebugArchitectures(projectRoot, iosProjectPath = "ios") {
+	const iosRoot = join(projectRoot, iosProjectPath);
+	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(await getExecutor().runFileAsync("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/integrations/react-native-doctor.ts
+function reactNativeProjectDoctor(root) {
+	return {
+		inspect: reactNativeDoctorFindings,
+		async inspectAsync({ options: { platform, host = process.platform, machineSettings, operation }, settings, repoRoot }) {
+			const iosProjectPath = resolveIosProjectDir(settings, root).relative;
+			const source = machineSettings?.corrupt ? [] : await checkMainCheckout(root, {
+				platform,
+				localIos: platform !== "android" && host === "darwin",
+				iosProjectPath,
+				androidLayout: resolveAndroidLayout(settings, root, repoRoot ?? root)
+			});
+			const architectures = !machineSettings?.corrupt && platform !== "android" && host === "darwin" ? await inspectIosDebugArchitectures(await mainCheckoutProjectRoot(root), iosProjectPath) : [];
+			const parity = await detectFingerprintParity(root, {
+				platform,
+				iosProjectPath,
+				operation
+			});
+			const linkedGit = await detectLinkedLibraryGitMetadata(root, {
+				platform,
+				operation
+			});
+			return [
+				...source,
+				...architectures,
+				parity,
+				linkedGit?.code === parity?.code ? null : linkedGit
+			].filter((finding) => finding !== null);
+		},
+		offloadTargets({ options: { platform, host = process.platform, operation }, settings, repoRoot }, iosRuntime) {
+			const checksIos = platform !== "android" && host === "darwin";
+			const androidDir = resolveAndroidLayout(settings, root, repoRoot ?? root).gradleRoot;
+			const checksAndroid = platform === "android" || platform === void 0 && (existsSync(androidDir) || detectIsExpo(root));
+			if (!checksIos && !checksAndroid) return null;
+			return async () => {
+				const targets = [];
+				if (checksIos) {
+					const [local, runtime] = await Promise.all([iosToolchainAsync(root), iosRuntime()]);
+					targets.push({
+						platform: "ios",
+						local,
+						runtime,
+						cocoapodsPinned: bundlerPin(root) !== null
+					});
+				}
+				if (checksAndroid) targets.push({
+					platform: "android",
+					local: operation ? await androidToolchainAsync(operation.env) : androidToolchain(),
+					requires: androidRequirements(root)
+				});
+				return targets;
+			};
+		},
+		repair: (platform, settings, repoRoot) => platform === "ios" ? {
+			removed: [],
+			refused: []
+		} : repairCxxLauncherState(root, settings, resolveAndroidLayout(settings, root, repoRoot ?? root)),
+		successLines: reactNativeDoctorSuccessLines
+	};
+}
+function reactNativeDoctorSuccessLines(platform) {
+	const lines = [
+		"",
+		"Project",
+		phaseLine("project", "source checkout, dependencies, local upstream, nested worktrees Watchman would crawl")
+	];
+	if (platform !== "android") {
+		lines.push("", "iOS");
+		lines.push(phaseLine("setup", "CocoaPods, warm state, effective Debug simulator architectures"));
+		lines.push(phaseLine("caches", "Metro, Xcode compilation, ccache, build provider"));
+		lines.push(phaseLine("devices", "remote device, SimSlim profile"));
+	}
+	if (platform !== "ios") {
+		lines.push("", "Android");
+		lines.push(phaseLine("setup", "Android SDK, warm state"));
+		lines.push(phaseLine("caches", "Metro, Gradle, ccache, build provider"));
+		lines.push(phaseLine("devices", "remote device"));
+	}
+	lines.push("", "Expo and React Native");
+	lines.push(phaseLine("services", "EAS session"));
+	lines.push(phaseLine("fingerprint", "parity when dependencies are absent"));
+	lines.push("", "Handled automatically");
+	const suppliedCaches = platform === "ios" ? "Metro transform store, Xcode compilation cache" : platform === "android" ? "Metro transform store, Gradle build cache, ccache" : "Metro transform store, Xcode compilation cache, Gradle build cache, ccache";
+	lines.push(phaseLine("caches", suppliedCaches));
+	lines.push(phaseLine("meaning", "missing project cache settings are healthy"));
+	return lines;
+}
+//#endregion
+export { reactNativeProjectDoctor };