stim 1.19.0 → 1.20.0

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

@@ -1,46 +1,15 @@
-import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-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 { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { o as androidHome } from "./android-BsYNR81W.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 { a as readCcacheActivity, n as CCACHE_UNAVAILABLE } from "./ccache-CjHQ5F8g.mjs";
+import { M as startBuildHeartbeat, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DqyDXs30.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 } = {}) {
-	if (platform !== "win32") return null;
-	const abiName = abi ?? LONGEST_ANDROID_ABI;
-	const tail = 198 + (/release$/i.test(variant ?? "") ? 14 : 5) - 5 + abiName.length;
-	const longest = root.length + tail;
-	if (longest < 240) return null;
-	return {
-		root,
-		abi: abiName,
-		longest,
-		maxRootLength: 239 - tail
-	};
-}
-function androidPathRoomMessage({ root, abi, longest, maxRootLength }) {
-	return `The project root ${root} is ${root.length} characters, so the longest known Android native object path (react_codegen_safeareacontext for ${abi}) reaches ${longest} characters, past the 239 the NDK's ninja can be given on Windows; the root can be at most ${maxRootLength} characters.`;
-}
-function androidPathRoomRemedy({ root }) {
-	return `Map the project to a drive letter (\`subst X: "${root}"\`) and run Stim from X:\\, or move it under a shorter root.`;
-}
+import chalk from "chalk";
 const MAX_MESSAGE_LENGTH = 300;
 const KOTLIN_URI = /^e:\s+file:\/\/(\/\S+?):(\d+):(\d+)\s+(.*)$/;
 const KOTLIN_PAREN = /^e:\s+(\S+?):\s*\((\d+),\s*(\d+)\):\s*(.*)$/;
@@ -342,7 +311,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$1(join(dir, "output-metadata.json"));
+	const metadata = readOrNull(join(dir, "output-metadata.json"));
 	if (metadata) {
 		const named = parseOutputMetadata(metadata);
 		if (named) {
@@ -570,7 +539,7 @@ function gradleArgs(task, { buildCache = true, projectArgs = [] } = {}) {
 		...projectArgs
 	];
 }
-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) } = {}) {
+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) } = {}) {
 	const sdk = androidHome(env);
 	const sdkExists = existsSync(sdk);
 	const refusal = androidSdkRefusal({
@@ -712,7 +681,16 @@ async function buildGradle({ root, logWriter, variant = null, project, task, pro
 			ccache: ccacheActivity
 		};
 	}
-	const located = locateApk(project, transcript, variant);
+	const located = locate ? await locate() : locateApk(project, transcript, variant);
+	if ("code" in located) return {
+		ok: false,
+		...located,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: tail.slice(),
+		durationMs,
+		ccache: ccacheActivity
+	};
 	if (!located.apkPath && located.candidates?.length) return {
 		ok: false,
 		code: BUILD_ERROR,
@@ -739,6 +717,7 @@ async function buildGradle({ root, logWriter, variant = null, project, task, pro
 		ok: true,
 		apkPath: located.apkPath,
 		apkNote: located.note ?? null,
+		...located.androidPackage ? { androidPackage: located.androidPackage } : {},
 		durationMs,
 		lastLines: tail.slice(),
 		ccache: ccacheActivity
@@ -776,7 +755,7 @@ function safeList(dir) {
 		return [];
 	}
 }
-function readOrNull$1(file) {
+function readOrNull(file) {
 	try {
 		return readFileSync(file, "utf-8");
 	} catch {
@@ -784,612 +763,4 @@ function readOrNull$1(file) {
 	}
 }
 //#endregion
-//#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 };
+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 };