stim 1.17.2 → 1.19.0

package/dist/{gradle-dJpre3Yn.mjs → device-ios-B2ruohE-.mjs}

@@ -1,14 +1,25 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
-import { o as androidHome } from "./android-B_YNZy61.mjs";
-import { O as readCcacheActivity, T as CCACHE_UNAVAILABLE, u as HEARTBEAT_INTERVAL_MS, y as startBuildHeartbeat } from "./toolchain-DNyR3NPq.mjs";
-import { createHash } from "node:crypto";
+import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
+import { C as saveConfig, D as withConfigLock, H as projectDeviceSlots, _ as loadConfig, a as clearDevice, d as getConfigDir, w as setDevice, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
+import { p as sharedCompilationCache, y as workspaceId } from "./workspace-state-CR9X86xJ.mjs";
+import { v as resolvePackageJson } from "./project-B5eQ1USs.mjs";
+import { Ot as resolveOptimizations, v as iosSimSlimProfileSetting } from "./settings-CxgngUZk.mjs";
+import { r as register } from "./cache-manifest-DiwKSyv9.mjs";
+import { j as teardownParkedIosSim } from "./workspaces-Djb2gfi9.mjs";
+import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
+import { ct as dropParked, ft as parkedMaxSetting, ht as selectParked, o as androidHome, pt as readParked, st as adoptParked } from "./android-BdQC6zs1.mjs";
+import { C as resetIosPrivacy, M as readHostMemoryPressure, S as resetIosKeychain, T as resolveOwnedIosSim, a as createOwnedIosSim, d as listAllIosSims, g as ownedSimName, j as hostMemoryPressureAdvice, k as configuredIosSimulatorViewer, m as listIosRuntimes, n as bootIosSim, p as listIosDeviceTypes, u as iosSimulatorFailureAdvice, v as parseRuntimeVersion, w as resolveIosCreation, x as renameIosSim } from "./ios-BWbHFZVz.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-B4iWH4E-.mjs";
+import { a as deviceTypeMismatch, c as runtimeMismatch, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission } from "./device-capacity-BoN1jQkO.mjs";
+import { o as readCcacheActivity, r as CCACHE_UNAVAILABLE } from "./manifest-CX0d1IkZ.mjs";
+import { D as swiftPrefixMappingSupported, E as startBuildHeartbeat, S as pickXcodeProject, _ as buildXcode, b as detectSwiftVersion, g as SWIFT_PREFIX_MAPPING_MIN_SWIFT, h as HEARTBEAT_INTERVAL_MS, x as detectXcodeMajor, y as compilationCacheSettings } from "./toolchain-C3xSoyUl.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import chalk from "chalk";
+import { createHash } from "node:crypto";
 /** 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 } = {}) {
@@ -290,44 +301,12 @@ function assembleTaskFor(variant) {
 }
 const LAST_LINES = 20;
 const TRANSCRIPT_LINES = 2e3;
-function androidDir(root) {
-	return join(root, "android");
-}
-function gradlewPath(root) {
-	return join(androidDir(root), process.platform === "win32" ? "gradlew.bat" : "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 }) {
+function androidSdkRefusal({ sdkPath, sdkExists, hasLocalProperties, localPropertiesPath }) {
 	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."
+		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.`
 	};
 }
 function pickDebugApk(files) {
@@ -363,7 +342,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) {
@@ -392,8 +371,7 @@ function listApkSubdirs(base, prefix = [], depth = 0) {
 	}
 	return dirs;
 }
-function findVariantApkDir(root, variant) {
-	const base = apkOutputsDir(root);
+function findVariantApkDir(base, variant) {
 	const wanted = variant.trim().toLowerCase();
 	for (const segments of listApkSubdirs(base)) if (variantNameOf(segments).toLowerCase() === wanted) return join(base, ...segments);
 	return null;
@@ -410,25 +388,25 @@ function findDebugApksUnder(base) {
 	}
 	return found.toSorted();
 }
-function locateApk(root, transcript = "", variant = null) {
+function locateApk(project, transcript = "", variant = null) {
 	const fromTranscript = parseApkFromTranscript(transcript);
 	if (fromTranscript) {
-		const abs = isAbsolute(fromTranscript) ? fromTranscript : join(androidDir(root), fromTranscript);
+		const abs = isAbsolute(fromTranscript) ? fromTranscript : join(project.directory, fromTranscript);
 		if (existsSync(abs)) return { apkPath: abs };
 	}
 	if (variant) {
-		const dir = findVariantApkDir(root, variant);
+		const dir = findVariantApkDir(project.outputsDir, variant);
 		return { apkPath: dir ? apkInDir(dir) : null };
 	}
-	const direct = apkInDir(debugApkDir(root));
+	const direct = apkInDir(join(project.outputsDir, "debug"));
 	if (direct) return { apkPath: direct };
-	const found = findDebugApksUnder(apkOutputsDir(root));
+	const found = findDebugApksUnder(project.outputsDir);
 	if (found.length === 1) {
 		const apk = found[0];
-		const suggested = variantNameOf(relative(apkOutputsDir(root), apk).split(sep).slice(0, -1));
+		const suggested = variantNameOf(relative(project.outputsDir, apk).split(sep).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` : ""}`
+			note: `no APK in ${relative(project.directory, join(project.outputsDir, "debug"))}; using ${relative(project.directory, apk)}${suggested ? ` -- set the android.variant setting to "${suggested}" to build this variant explicitly` : ""}`
 		};
 	}
 	if (found.length > 1) return {
@@ -585,48 +563,21 @@ function parseProductFlavors(source) {
 		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 } = {}) {
+function gradleArgs(task, { buildCache = true, projectArgs = [] } = {}) {
 	return [
 		task,
 		...buildCache ? ["--build-cache"] : ["--no-build-cache"],
-		...abi ? [`-PreactNativeArchitectures=${abi}`] : []
+		...projectArgs
 	];
 }
-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), platform = process.platform } = {}) {
-	const project = discoverAndroidProject(root);
-	if (project.failed) return {
-		ok: false,
-		code: project.code,
-		reason: project.reason,
-		remedy: project.remedy,
-		diagnostics: [],
-		truncated: 0,
-		lastLines: [],
-		durationMs: 0
-	};
+async function buildGradle({ root, logWriter, variant = null, project, task, projectArgs = [], preflightFailure = 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 sdk = androidHome(env);
 	const sdkExists = existsSync(sdk);
 	const refusal = androidSdkRefusal({
 		sdkPath: sdk,
 		sdkExists,
-		hasLocalProperties: existsSync(join(project.androidDir, "local.properties"))
+		hasLocalProperties: existsSync(join(project.directory, "local.properties")),
+		localPropertiesPath: relative(root, join(project.directory, "local.properties")).split(sep).join("/")
 	});
 	if (refusal) return {
 		ok: false,
@@ -636,26 +587,21 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 		lastLines: [],
 		durationMs: 0
 	};
-	const room = androidPathRoom(root, {
-		abi,
-		variant,
-		platform
-	});
-	if (room) return {
+	if (preflightFailure) return {
 		ok: false,
-		code: "STIM_PATH_TOO_LONG",
-		reason: androidPathRoomMessage(room),
-		remedy: androidPathRoomRemedy(room),
+		...preflightFailure,
 		diagnostics: [],
 		truncated: 0,
 		lastLines: [],
 		durationMs: 0
 	};
+	const wrapper = `./${relative(project.directory, project.gradlew).split(sep).join("/")}`;
+	const moduleTask = task.includes(":") ? task : `${project.module === ":" ? "" : project.module}:${task}`;
+	const tasksTask = `${project.module === ":" ? "" : project.module}:tasks`;
 	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
-	const task = assembleTaskFor(variant);
 	const args = gradleArgs(task, {
 		buildCache,
-		abi
+		projectArgs
 	});
 	if (cas) {
 		args.push("--init-script", cas.initScript);
@@ -709,7 +655,7 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 	let child;
 	try {
 		child = spawnDeclared(() => spawn(project.gradlew, args, {
-			cwd: project.androidDir,
+			cwd: project.directory,
 			stdio: [
 				"ignore",
 				"pipe",
@@ -726,7 +672,7 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 			}
 		}));
 	} catch (err) {
-		return spawnFailure(err, project, now() - startedAt);
+		return spawnFailure(err, root, project, now() - startedAt);
 	}
 	const outReader = createLineReader(push);
 	const errReader = createLineReader(push);
@@ -748,7 +694,7 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 	const transcript = window.join("\n");
 	const ccacheActivity = ccache ? readCcacheActivity(ccache.statsLog) : CCACHE_UNAVAILABLE;
 	if (result.error) return {
-		...spawnFailure(result.error, project, durationMs),
+		...spawnFailure(result.error, root, project, durationMs),
 		lastLines: tail.slice(),
 		ccache: ccacheActivity
 	};
@@ -758,7 +704,7 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 		return {
 			ok: false,
 			code: BUILD_ERROR,
-			reason: `\`./gradlew ${task}\` failed (${how}).`,
+			reason: `\`${wrapper} ${task}\` failed (${how}).`,
 			diagnostics: shown,
 			truncated,
 			lastLines: tail.slice(),
@@ -766,23 +712,23 @@ async function buildAndroid({ root, logWriter, variant = null, abi = null }, { s
 			ccache: ccacheActivity
 		};
 	}
-	const located = locateApk(root, transcript, variant);
+	const located = locateApk(project, transcript, variant);
 	if (!located.apkPath && located.candidates?.length) return {
 		ok: false,
 		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(sep).slice(0, -1))}"}} in .stim.json.`,
+		reason: `\`${wrapper} ${task}\` left ${located.candidates.length} debug APKs under ${project.outputsDir}, and nothing says which flavor to install.`,
+		remedy: `Set the android.variant setting to the variant to install -- e.g. {"android": {"variant": "${variantNameOf(relative(project.outputsDir, located.candidates[0]).split(sep).slice(0, -1))}"}} in .stim.json.`,
 		diagnostics: [],
 		truncated: 0,
-		lastLines: located.candidates.map((c) => relative(androidDir(root), c)),
+		lastLines: located.candidates.map((c) => relative(project.directory, c)),
 		durationMs,
 		ccache: ccacheActivity
 	};
 	if (!located.apkPath) return {
 		ok: false,
 		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.`,
+		reason: variant ? `\`${wrapper} ${task}\` succeeded but produced no APK under ${project.outputsDir} for variant "${variant}".` : `\`${wrapper} ${task}\` succeeded but produced no APK in ${join(project.outputsDir, "debug")}.`,
+		remedy: variant ? `Check that the android.variant setting ("${variant}") names a real variant (\`${wrapper} ${tasksTask}\` lists the assemble tasks).` : `Check that ${task} builds the ${project.module.replace(/^:/, "") || "root"} module (\`${wrapper} ${moduleTask}\` in ${relative(root, project.directory).split(sep).join("/") || "."}/) and that no flavour redirects the output.`,
 		diagnostics: [],
 		truncated: 0,
 		lastLines: tail.slice(),
@@ -804,7 +750,7 @@ function resetStatsLog(statsLog) {
 		rmSync(statsLog, { force: true });
 	} catch {}
 }
-function spawnFailure(err, project, durationMs) {
+function spawnFailure(err, root, project, durationMs) {
 	const nodeErr = err;
 	const message = String(nodeErr?.message || err || "");
 	const permissionDenied = nodeErr?.code === "EACCES" || /EACCES|permission denied/i.test(message);
@@ -812,7 +758,7 @@ function spawnFailure(err, project, durationMs) {
 		ok: false,
 		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.",
+		remedy: permissionDenied ? `Make the wrapper executable: \`chmod +x ${project.gradlew}\`.` : `Check that the gradle wrapper is intact (${relative(root, project.gradlew)} and ${relative(root, join(project.directory, "gradle", "wrapper"))}/) and that JAVA_HOME points at a JDK 17 install.`,
 		diagnostics: [],
 		truncated: 0,
 		lastLines: [],
@@ -830,7 +776,7 @@ function safeList(dir) {
 		return [];
 	}
 }
-function readOrNull(file) {
+function readOrNull$1(file) {
 	try {
 		return readFileSync(file, "utf-8");
 	} catch {
@@ -838,4 +784,612 @@ function readOrNull(file) {
 	}
 }
 //#endregion
-export { gradlewPath as a, formatDiagnostic as c, androidPathRoomRemedy as d, buildAndroid as i, androidPathRoom as l, apkOutputsDir as n, productFlavorRefusal as o, assembleTaskFor as r, readProductFlavors as s, androidSdkRefusal as t, androidPathRoomMessage as u };
+//#region src/integrations/react-native-build.ts
+function androidDir(root) {
+	return join(root, "android");
+}
+function gradlewPath(root) {
+	return join(androidDir(root), process.platform === "win32" ? "gradlew.bat" : "gradlew");
+}
+function apkOutputsDir(root) {
+	return join(androidDir(root), "app", "build", "outputs", "apk");
+}
+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 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 readOrNull(path) {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function buildAndroid({ root, logWriter, variant = null, abi = null }, options = {}) {
+	const project = discoverAndroidProject(root);
+	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: ":app",
+			outputsDir: apkOutputsDir(root)
+		},
+		task: assembleTaskFor(variant),
+		projectArgs: abi ? [`-PreactNativeArchitectures=${abi}`] : [],
+		preflightFailure: room ? {
+			code: "STIM_PATH_TOO_LONG",
+			reason: androidPathRoomMessage(room),
+			remedy: androidPathRoomRemedy(room)
+		} : null
+	}, options);
+}
+const IOS_DIR = "ios";
+const PREBUILD_REMEDY = "Generate it with `npx expo prebuild -p ios` (stim ios does this automatically for an Expo project with no ios/ directory), or commit the native project.";
+function buildFailure(message, remedy) {
+	return { error: {
+		code: "STIM_BUILD_FAILED",
+		message,
+		remedy
+	} };
+}
+function discoverXcodeProject(root) {
+	const dir = join(root, IOS_DIR);
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return buildFailure(`No ${IOS_DIR}/ directory in ${root}.`, PREBUILD_REMEDY);
+	}
+	const picked = pickXcodeProject(entries);
+	if (!picked) return buildFailure(`${dir} contains no .xcworkspace and no .xcodeproj.`, PREBUILD_REMEDY);
+	return {
+		...picked,
+		dir,
+		path: join(dir, picked.file)
+	};
+}
+function ccacheEnabled(podfileProperties) {
+	if (!podfileProperties || typeof podfileProperties !== "object") return false;
+	return podfileProperties["apple.ccacheEnabled"] === "true";
+}
+function readPodfileProperties(root) {
+	try {
+		const parsed = JSON.parse(readFileSync(join(root, IOS_DIR, "Podfile.properties.json"), "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const SWIFT_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)
+	});
+}
+function resolveCompilationCacheSettings({ root, derivedDataPath, exec = null, casPath = sharedCompilationCache(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
+	const xcodeMajor = detectXcodeMajor(exec);
+	const ccache = ccacheEnabled(readPodfileProperties(root));
+	const probe = xcodeMajor !== null && xcodeMajor >= 26 && !ccache && optimizations.compilationCache && optimizations.swiftCompilationCache !== false;
+	const swiftVersion = probe ? detectSwiftVersion(exec) : null;
+	const reactNativeVersion = probe ? detectReactNativeVersion(root) : null;
+	const settings = reactNativeCompilationCacheSettings({
+		workspaceRoot: root,
+		derivedDataPath,
+		casPath,
+		xcodeMajor,
+		swiftVersion,
+		reactNativeVersion,
+		ccache,
+		optimizations
+	});
+	if (settings.length > 0 && optimizations.compilationCache) {
+		register({
+			dir: casPath,
+			name: "Xcode compilation cache",
+			prune: "atomic",
+			note: "shared Xcode compilation cache"
+		});
+		const swift = settings.includes("SWIFT_ENABLE_COMPILE_CACHE=YES") ? settings.includes("SWIFT_ENABLE_PREFIX_MAPPING=YES") ? "Swift on" : "Swift on, unmapped" : swiftVersion && !swiftPrefixMappingSupported(swiftVersion) ? `Swift off, ${swiftVersion.major}.${swiftVersion.minor} < ${SWIFT_PREFIX_MAPPING_MIN_SWIFT.major}.${SWIFT_PREFIX_MAPPING_MIN_SWIFT.minor}` : swiftVersion && reactNativeVersion && !reactNativeSupportsSwiftCache(reactNativeVersion) ? `Swift off, react-native ${reactNativeVersion.major}.${reactNativeVersion.minor} < ${SWIFT_CACHE_MIN_REACT_NATIVE.major}.${SWIFT_CACHE_MIN_REACT_NATIVE.minor}` : "Swift off";
+		onNote(chalk.dim(phaseLine("cache", `compilation cache on (CAS at ${casPath}, ${swift})`)));
+	}
+	return settings;
+}
+async function buildIos(inputs) {
+	const { root, 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),
+		compilationCache: inputs.compilationCache === void 0 ? ({ derivedDataPath, exec }) => resolveCompilationCacheSettings({
+			root,
+			derivedDataPath,
+			exec,
+			optimizations: inputs.optimizations,
+			onNote: inputs.onNote
+		}) : inputs.compilationCache
+	});
+}
+//#endregion
+//#region src/engine/device-ios.ts
+function startIosBoot(udid, configure, label, out, simulatorApp, root, deviceSlotWait) {
+	const done = withDeviceBootAdmission({
+		platform: "ios",
+		key: udid
+	}, async () => {
+		out(chalk.dim(phaseLine("device", `booting ${label} (${udid})`)));
+		await bootIosSim(udid, {
+			label,
+			out,
+			simulatorApp
+		});
+		await configure();
+	}, {
+		...deviceSlotWait,
+		root,
+		out
+	});
+	done.catch(() => {});
+	return {
+		udid,
+		done
+	};
+}
+var IosDeviceMismatchError = class extends Error {
+	remedy = "Run `stim worktree remove` (or `stim gc --delete`) to reap the current sim, then `stim ios` again to create the requested one, or pass `--slot <name>` to create it beside the current one.";
+};
+async function ensureOwnedIosDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, reconcileIosSimulator, simSnapshot }) {
+	const memoryAdvice = hostMemoryPressureAdvice(readHostMemoryPressure());
+	if (memoryAdvice) out(chalk.yellow(phaseLine("memory", memoryAdvice)));
+	const simslimProfile = iosSimSlimProfileSetting(settings, settingsRoot);
+	if (record?.deviceUdid) {
+		if (record.owned) {
+			const listed = simSnapshot ? simSnapshot.read() : listAllIosSims({ includeUnavailable: true });
+			const resolved = resolveOwnedIosSim(record.deviceUdid, listed);
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned -- creating a fresh owned sim instead of booting it.`));
+			else if (resolved.missing) {} else {
+				const sim = resolved.sim;
+				const wantedType = flags.deviceType || settings?.ios?.deviceType;
+				const deviceTypes = listIosDeviceTypes();
+				const mismatch = deviceTypeMismatch(sim.deviceTypeIdentifier, wantedType, deviceTypes);
+				if (mismatch) throw new IosDeviceMismatchError(`${mismatch}. Stim will not silently boot a different model.`);
+				const versionMismatch = flags.runtimeFlag ? runtimeMismatch(sim.runtime, flags.runtimeFlag, listIosRuntimes()) : null;
+				if (versionMismatch) throw new IosDeviceMismatchError(`${versionMismatch}. Stim will not silently boot a different iOS version.`);
+				const model = {
+					model: deviceTypes.find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null,
+					runtime: parseRuntimeVersion(sim.runtime)
+				};
+				const name = ownedIosName(sim, label, model, projectPath, listed) === sim.name ? sim.name : await withIosDeviceNameLock(() => renameToOwnedName(sim, label, model, projectPath));
+				const updated = {
+					deviceUdid: sim.udid,
+					owned: true,
+					deviceName: name,
+					...record.simslimManaged ? { simslimManaged: true } : {},
+					...record.adopted ? { adopted: true } : {},
+					...record.adoptionPending ? { adoptionPending: true } : {},
+					...record.parkedCacheKey ? { parkedCacheKey: record.parkedCacheKey } : {},
+					...record.schemeApprovals ? { schemeApprovals: record.schemeApprovals } : {}
+				};
+				const configure = async () => {
+					if (record.adoptionPending) resetAdoptedSim(sim.udid, out);
+					return configureOwnedIosSim({
+						record: updated,
+						projectPath,
+						slot,
+						profile: simslimProfile,
+						out,
+						reconcileIosSimulator
+					});
+				};
+				const facts = {
+					deviceType: model.model,
+					runtime: model.runtime
+				};
+				if (sim.state !== "Booted") return {
+					...updated,
+					booting: startIosBoot(sim.udid, configure, name, out, flags.simulatorApp, projectPath, flags.deviceSlotWait),
+					...facts
+				};
+				return {
+					...await configure(),
+					...facts,
+					booted: sim.udid
+				};
+			}
+		} else {
+			const sim = listAllIosSims().find((s) => s.udid === record.deviceUdid);
+			if (sim) {
+				if (sim.state !== "Booted") {
+					note(chalk.yellow(`Note: assigned sim ${sim.name} (${sim.udid}) is shut down and is not owned by Stim, so it will not be booted automatically.`));
+					note(chalk.dim("Boot it yourself, or run `stim gc --delete` to clear the assignment so Stim can create an owned sim."));
+				}
+				return record;
+			}
+		}
+		withConfigLock(() => {
+			const current = deviceSlotPlatforms(loadConfig()?.projects?.[projectPath], slot)?.ios;
+			if (!current) return;
+			if (current.deviceUdid !== record.deviceUdid || current.owned !== record.owned) throw new Error("The simulator assignment changed during recovery. Run `stim ios` again.");
+			clearDevice(projectPath, "ios", slot);
+		});
+	}
+	const choice = resolveIosCreation({
+		deviceType: flags.deviceType || settings.ios?.deviceType,
+		runtime: flags.runtime || settings.ios?.runtime
+	});
+	const adopted = parkedMaxSetting("ios").max > 0 ? await withIosDeviceNameLock(() => takeParkedIosSim({
+		projectPath,
+		slot,
+		label,
+		choice,
+		out
+	})) : null;
+	if (adopted) {
+		const booting = startIosBoot(adopted.deviceUdid, async () => {
+			resetAdoptedSim(adopted.deviceUdid, out);
+			await configureOwnedIosSim({
+				record: adopted,
+				projectPath,
+				slot,
+				profile: simslimProfile,
+				out,
+				reconcileIosSimulator
+			});
+		}, adopted.deviceName, out, flags.simulatorApp, projectPath, flags.deviceSlotWait);
+		return {
+			...adopted,
+			booting,
+			deviceType: choice.deviceType,
+			runtime: choice.runtime
+		};
+	}
+	const created = await withIosDeviceNameLock(() => {
+		const suffix = ownedIosNameSuffix(label, {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		}, projectPath);
+		const result = createOwnedIosSim(label, { suffix }, choice);
+		setDevice(projectPath, "ios", {
+			deviceUdid: result.udid,
+			owned: true,
+			deviceName: result.name
+		}, slot);
+		return result;
+	});
+	const newRecord = {
+		deviceUdid: created.udid,
+		owned: true,
+		deviceName: created.name
+	};
+	const booting = startIosBoot(created.udid, () => configureOwnedIosSim({
+		record: newRecord,
+		projectPath,
+		slot,
+		profile: simslimProfile,
+		out,
+		reconcileIosSimulator
+	}), created.name, out, flags.simulatorApp, projectPath, flags.deviceSlotWait);
+	return {
+		...newRecord,
+		created: true,
+		booting,
+		deviceType: created.deviceType,
+		runtime: created.runtime
+	};
+}
+function withIosDeviceNameLock(fn) {
+	return withWorkspaceProcessLock(getConfigDir(), "ios-device-names", async () => fn(), { external: true });
+}
+function ownedIosNameSuffix(label, model, projectPath, udid, listed = listAllIosSims({ includeUnavailable: true })) {
+	const names = new Set(listed.filter((sim) => sim.udid !== udid).map((sim) => sim.name));
+	for (const project of Object.values(loadConfig()?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
+		const record = platforms.ios;
+		if (record?.deviceUdid !== udid && record?.deviceName) names.add(record.deviceName);
+	}
+	for (const parked of readParked("ios")) if (parked.udid !== udid) names.add(parked.name);
+	let suffix = "";
+	for (let attempt = 0; names.has(ownedSimName(label, model, suffix)); attempt++) suffix = ` ${workspaceId(projectPath)}${attempt ? `-${attempt}` : ""}`;
+	return suffix;
+}
+function ownedIosName(sim, label, model, projectPath, listed) {
+	return ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, sim.udid, listed));
+}
+function renameToOwnedName(sim, label, model, projectPath) {
+	const wanted = ownedIosName(sim, label, model, projectPath);
+	if (sim.name === wanted) return wanted;
+	try {
+		renameIosSim(sim.udid, wanted);
+		return wanted;
+	} catch {
+		return sim.name;
+	}
+}
+function resetAdoptedSim(udid, out) {
+	out(chalk.dim(phaseLine("device", `resetting privacy grants and the keychain on ${udid}`)));
+	resetIosPrivacy(udid);
+	resetIosKeychain(udid);
+}
+function takeParkedIosSim({ projectPath, slot, label, choice, out }) {
+	const candidates = selectParked(readParked("ios"), {
+		deviceTypeIdentifier: choice.deviceTypeId,
+		runtimeIdentifier: choice.runtimeId
+	});
+	if (candidates.length === 0) return null;
+	const listed = new Map(listAllIosSims({ includeUnavailable: true }).map((sim) => [sim.udid, sim]));
+	for (const parked of candidates) {
+		const sim = listed.get(parked.udid);
+		if (!sim || !sim.available) {
+			const result = sim ? teardownParkedIosSim(parked.udid, { label: parked.name }) : null;
+			if (sim ? result?.status === "torn-down" : dropParked("ios", parked.udid)) out(chalk.dim(phaseLine("device", `deleted parked ${parked.name} (${parked.udid}): ${sim ? "unavailable" : "gone"}`)));
+			else if (result?.status === "failed") out(chalk.yellow(phaseLine("device", `could not delete unavailable parked ${parked.name} (${parked.udid}): ${result.reason}`)));
+			continue;
+		}
+		if (!sim.name.startsWith("stim-")) {
+			out(chalk.yellow(phaseLine("device", `kept parked record for ${parked.udid}: simulator is now named ${JSON.stringify(sim.name)} and is not Stim-owned`)));
+			continue;
+		}
+		const model = {
+			model: choice.deviceType,
+			runtime: choice.runtime
+		};
+		const name = ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, parked.udid));
+		const device = {
+			deviceUdid: parked.udid,
+			owned: true,
+			deviceName: name,
+			adopted: true,
+			adoptionPending: true,
+			...parked.simslimManaged ? { simslimManaged: true } : {},
+			...parked.cacheKey ? { parkedCacheKey: parked.cacheKey } : {}
+		};
+		const adopted = adoptParked({
+			platform: "ios",
+			projectPath,
+			slot,
+			udid: parked.udid,
+			device
+		});
+		if (!adopted) continue;
+		try {
+			renameIosSim(parked.udid, name);
+		} catch {}
+		return adopted.schemeApprovals && adopted.schemeApprovals.length > 0 ? {
+			...device,
+			schemeApprovals: adopted.schemeApprovals
+		} : device;
+	}
+	return null;
+}
+function clearIosAdoptionPending(projectPath, slot = "default") {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
+		if (!cfg || !ios?.adoptionPending) return;
+		delete ios.adopted;
+		delete ios.adoptionPending;
+		delete ios.parkedCacheKey;
+		saveConfig(cfg);
+	});
+}
+async function configureOwnedIosSim({ record, projectPath, slot, profile, out, reconcileIosSimulator }) {
+	if (profile) out(chalk.dim(phaseLine("device", `applying the SimSlim profile to ${record.deviceUdid}`)));
+	else if (record.simslimManaged) out(chalk.dim(phaseLine("device", `restoring stock simulator services on ${record.deviceUdid}`)));
+	const previouslyManaged = Boolean(record.simslimManaged);
+	if (profile && !record.simslimManaged) {
+		const pending = {
+			...record,
+			simslimManaged: true
+		};
+		setDevice(projectPath, "ios", pending, slot);
+		record = pending;
+	}
+	const result = await reconcileIosSimulator({
+		udid: record.deviceUdid,
+		profile,
+		previouslyManaged,
+		out
+	});
+	const updated = { ...record };
+	if (result.managed) updated.simslimManaged = true;
+	else delete updated.simslimManaged;
+	setDevice(projectPath, "ios", updated, slot);
+	return updated;
+}
+async function ensureIosBooted({ device, projectPath, deviceSlotWait, simulatorApp, timeoutMs, pollMs, out }) {
+	const udid = device?.deviceUdid;
+	if (!udid) return {
+		failed: true,
+		reason: "No iOS simulator is recorded for this project."
+	};
+	const ready = () => {
+		try {
+			getExecutor().runFile("xcrun", [
+				"simctl",
+				"spawn",
+				udid,
+				"launchctl",
+				"list"
+			], { timeoutMs: 3e4 });
+			return {
+				ok: true,
+				udid
+			};
+		} catch (error) {
+			return {
+				failed: true,
+				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${iosSimulatorFailureAdvice()}`
+			};
+		}
+	};
+	const booting = device?.booting;
+	if (booting?.udid === udid) {
+		try {
+			await booting.done;
+		} catch (e) {
+			return bootFailure(udid, e);
+		}
+		return ready();
+	}
+	const readiness = device?.booted === udid ? ready() : null;
+	if (readiness?.ok) {
+		if (simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
+		return readiness;
+	}
+	let resolved;
+	try {
+		resolved = resolveOwnedIosSim(udid);
+	} catch (e) {
+		return {
+			failed: true,
+			reason: `Could not list simulators: ${e?.message || e}`
+		};
+	}
+	if (resolved.missing) return {
+		failed: true,
+		reason: `Simulator ${udid} no longer exists. Run \`stim ios\` again to create a fresh owned sim.`
+	};
+	if (resolved.notOwned) return {
+		failed: true,
+		reason: `Simulator ${udid} is now named "${resolved.notOwned}" and is not Stim-owned; refusing to boot it.`
+	};
+	const sim = resolved.sim;
+	if (sim.state === "Booted") {
+		const result = readiness ?? ready();
+		if (result.ok && simulatorApp !== void 0) configuredIosSimulatorViewer(simulatorApp).open(udid);
+		return result;
+	}
+	const bootDeadline = Date.now() + timeoutMs;
+	try {
+		await withDeviceBootAdmission({
+			platform: "ios",
+			key: udid
+		}, () => {
+			out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
+			return bootIosSim(udid, {
+				timeoutMs,
+				label: sim.name,
+				out,
+				simulatorApp
+			});
+		}, {
+			...deviceSlotWait,
+			root: projectPath,
+			out
+		});
+	} catch (e) {
+		return bootFailure(udid, e);
+	}
+	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
+	while (Date.now() < deadline) {
+		await sleep(pollMs);
+		let state = null;
+		try {
+			state = listAllIosSims({ timeoutMs: 3e4 }).find((s) => s.udid === udid)?.state ?? null;
+		} catch {}
+		if (state === "Booted") return ready();
+	}
+	return {
+		failed: true,
+		reason: `Simulator ${udid} did not reach the Booted state within ${Math.round(timeoutMs / 1e3)}s.`
+	};
+}
+function bootFailure(udid, error) {
+	const refusal = error instanceof DeviceAdmissionRefusal ? error : (0, ownership_claim_exports.claimFailure)(error, "stim ios");
+	if (refusal) return {
+		failed: true,
+		code: refusal.code,
+		reason: refusal.message,
+		remedy: refusal.remedy
+	};
+	return {
+		failed: true,
+		reason: `Could not boot simulator ${udid}: ${error?.message || error}`
+	};
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#endregion
+export { androidPathRoomMessage as _, apkOutputsDir as a, ccacheEnabled as c, productFlavorRefusal as d, readProductFlavors as f, androidPathRoom as g, formatDiagnostic as h, ensureOwnedIosDevice as i, discoverXcodeProject as l, assembleTaskFor as m, clearIosAdoptionPending as n, buildAndroid as o, androidSdkRefusal as p, ensureIosBooted as r, buildIos as s, IosDeviceMismatchError as t, gradlewPath as u, androidPathRoomRemedy as v };