stim 1.19.0 → 1.20.0

package/dist/{device-capacity-BoN1jQkO.mjs → device-capacity-Ca_ke1LE.mjs}

@@ -1,15 +1,15 @@
 import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
-import { H as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir, u as getConcurrencyLimits, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
-import { x as workspaceLogsDir$1 } from "./workspace-state-CR9X86xJ.mjs";
-import { E as projectDeviceReclaimIdleMinutes } from "./settings-CxgngUZk.mjs";
-import { H as recordCapacityWait, V as recordCapacityRefusal } from "./budget-Dz-kyXLv.mjs";
-import { L as canonicalPath, f as withIdleWorkspace } from "./workspaces-Djb2gfi9.mjs";
-import { O as listAdbDevices } from "./android-BdQC6zs1.mjs";
-import { d as listAllIosSims, l as iosRuntimeMatches, v as parseRuntimeVersion } from "./ios-BWbHFZVz.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-B4iWH4E-.mjs";
-import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
-import { n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-DYiMBn34.mjs";
+import { H as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir, u as getConcurrencyLimits, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { g as deviceReclaimIdleMinutesSetting } from "./settings-Bbztm4oV.mjs";
+import { w as workspaceLogsDir$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { O as listAdbDevices } from "./android-BsYNR81W.mjs";
+import { T as canonicalPath, f as withIdleWorkspace } from "./workspaces-D2xSHBDY.mjs";
+import { Nt as recordCapacityRefusal, Pt as recordCapacityWait } from "./budget-BONq9vXY.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-C2lvoPsb.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { d as listAllIosSims, l as iosRuntimeMatches, y as parseRuntimeVersion } from "./ios-CXLIUxXJ.mjs";
+import { n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-DdMqoSUB.mjs";
 import { realpathSync } from "node:fs";
 import { basename, join } from "node:path";
 import { DEVICE_RECLAIM_REASON, automaticMachineEnabled } from "@stim-cli/core/state";
@@ -373,7 +373,7 @@ async function admissionTransaction(action, lockWaitMs, out, signal) {
 	}
 }
 /** Boots an owned device under the Stim home's cap, reserving capacity before releasing admission. */
-async function withDeviceBootAdmission(device, boot, { root, max = getConcurrencyLimits().maxDevices, sources = {}, lockWaitMs = ADMISSION_LOCK_WAIT_MS, out = () => {}, waitMs = DEFAULT_DEVICE_SLOT_WAIT_MS, noWait = false, automatic = false, displayName = basename(root), now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitingFor = () => {}, onWait = () => {} }) {
+async function withDeviceBootAdmission(device, boot, { root, max = getConcurrencyLimits().maxDevices, sources = {}, lockWaitMs = ADMISSION_LOCK_WAIT_MS, out = () => {}, waitMs = DEFAULT_DEVICE_SLOT_WAIT_MS, noWait = false, automatic = false, displayName = basename(root), reclaimIdleMinutes = deviceReclaimIdleMinutesSetting({}), now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitingFor = () => {}, onWait = () => {} }) {
 	const requireMembership = () => {
 		if (automatic && !automaticMachineEnabled("device", "local")) throw new DeviceAdmissionRefusal({
 			code: "STIM_HOSTING_REFUSED",
@@ -488,8 +488,7 @@ async function withDeviceBootAdmission(device, boot, { root, max = getConcurrenc
 				if (result.reclaim && now() - lastReclaim >= 15e3) {
 					lastReclaim = now();
 					try {
-						const minutes = projectDeviceReclaimIdleMinutes(canonicalPath(root));
-						if (minutes > 0) reclaimed += await reclaimIdleDevice(root, minutes * 6e4, out, now, skippedReclaims);
+						if (reclaimIdleMinutes > 0) reclaimed += await reclaimIdleDevice(root, reclaimIdleMinutes * 6e4, out, now, skippedReclaims);
 					} catch (error) {
 						out(phaseLine("device", `could not reclaim an idle device: ${error?.message || error}`));
 					}

package/dist/device-host-worker.mjs

@@ -1,26 +1,26 @@
 import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { D as withConfigLock$1, _ as loadConfig$1, c as ensureConfig } from "./config-DC5jEtd1.mjs";
-import { c as writeWorkspaceState, u as ensureWorkspaceStorage } from "./workspace-state-CR9X86xJ.mjs";
-import { D as teardownOwnedAvd, k as teardownOwnedIosSim } from "./workspaces-Djb2gfi9.mjs";
-import { t as forgetCreatedDevice } from "./created-devices-D0s26Hx5.mjs";
-import { A as listAvds, B as ownedAvdSystemImage, D as hostSystemImageArch, E as getAvdNameForSerial, J as resolveOwnedAvdSerial, O as listAdbDevices, R as ownedAvdName, W as pickDefaultSystemImage, _ as avdStorageRoots, a as androidDeviceAbi, b as createOwnedAvd, d as androidToolPath, f as assertOwnedAvdStopped, h as avdPathExists, j as listInstalledSystemImages, k as listAvdDeviceProfiles, q as resetAdoptedAvd, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, v as bootAndroidEmulator } from "./android-BdQC6zs1.mjs";
-import { C as resetIosPrivacy, M as readHostMemoryPressure, O as uninstallIosApp, S as resetIosKeychain, a as createOwnedIosSim, d as listAllIosSims, h as listUserApps, n as bootIosSim, w as resolveIosCreation } from "./ios-BWbHFZVz.mjs";
-import { i as macosProcess, o as requiredMacosRecord } from "./state-Tp4uImDS.mjs";
-import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
-import { i as countLiveOwnedDevices } from "./device-capacity-BoN1jQkO.mjs";
-import { C as reverseMetroPorts, _ as installIosApp, b as launchAndroidReleaseApp, h as installAndroidApp, s as androidAppProcess, v as iosAppProcess, w as writeDebugHttpHost, x as launchIosApp, y as launchAndroidApp } from "./app-install-CFI4ptUL.mjs";
-import { h as findAapt } from "./support-DsNaFg6D.mjs";
-import { n as parseLogcatLine, r as parsePidof, t as androidClockOffset } from "./android-DE5g_5gv.mjs";
-import { r as stopMacosAppHeld } from "./stop-D0UIpZuh.mjs";
-import { n as parseLogStreamLine } from "./ios-DCrkgXEM.mjs";
+import { D as withConfigLock$1, _ as loadConfig$1, c as ensureConfig } from "./config-D0LhTY3S.mjs";
+import { c as writeWorkspaceState, p as ensureWorkspaceStorage } from "./workspace-state-CSIFuuDa.mjs";
+import { A as listAvds, B as ownedAvdSystemImage, D as hostSystemImageArch, E as getAvdNameForSerial, J as resolveOwnedAvdSerial, O as listAdbDevices, R as ownedAvdName, W as pickDefaultSystemImage, _ as avdStorageRoots, a as androidDeviceAbi, b as createOwnedAvd, d as androidToolPath, f as assertOwnedAvdStopped, h as avdPathExists, j as listInstalledSystemImages, k as listAvdDeviceProfiles, q as resetAdoptedAvd, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, v as bootAndroidEmulator } from "./android-BsYNR81W.mjs";
+import { t as forgetCreatedDevice } from "./created-devices-HU_DAb_Q.mjs";
+import { b as teardownOwnedIosSim, v as teardownOwnedAvd } from "./workspaces-D2xSHBDY.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { C as resetIosKeychain, P as readHostMemoryPressure, T as resolveIosCreation, a as createOwnedIosSim, d as listAllIosSims, g as listUserApps, k as uninstallIosApp, n as bootIosSim, w as resetIosPrivacy } from "./ios-CXLIUxXJ.mjs";
+import { i as macosProcess, o as requiredMacosRecord } from "./state-Boo0IMJq.mjs";
+import { C as reverseMetroPorts, _ as installIosApp, b as launchAndroidReleaseApp, h as installAndroidApp, s as androidAppProcess, v as iosAppProcess, w as writeDebugHttpHost, x as launchIosApp, y as launchAndroidApp } from "./app-install-0LgaQRT7.mjs";
+import { i as countLiveOwnedDevices } from "./device-capacity-Ca_ke1LE.mjs";
+import { _ as findAapt } from "./support-CnE_SIjt.mjs";
+import { n as parseLogcatLine, r as parsePidof, t as androidClockOffset } from "./android-CK3fpEyZ.mjs";
+import { r as stopMacosAppHeld } from "./stop-WQPQHLuy.mjs";
+import { n as parseLogStreamLine } from "./ios-VGvNdsv2.mjs";
 import { chmodSync, closeSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statfsSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, posix, relative, sep } from "node:path";
 import { assertHostedDeviceLedger, hostedAppArea, hostedAppAttempt, hostedAppBlobs, hostedConsolePort, hostedMacosAppSlot, hostedMacosBundleId, hostedNativeLogsDir, isJsonObject, parseHostedOfferRequest, readHostedApp, readHostedAppMetadata, readHostedDevice, readHostedNativeLogsCheckpoint, readMacosRecord, readNdjsonGenerations } from "@stim-cli/core/state";
-import { availableParallelism, freemem, homedir, loadavg } from "node:os";
 import { LOG_ROTATE_BYTES, configDir, withDirLock } from "@stim-cli/core";
 import { createHash, randomUUID } from "node:crypto";
+import { availableParallelism, freemem, homedir, loadavg } from "node:os";
 //#region src/device-host/android-app.ts
 async function digest$1(path) {
 	const hash = createHash("sha256");
@@ -747,7 +747,17 @@ async function runHostedAndroidDevice(mode, request, app) {
 				openViewer: false,
 				logFile: join(home, "emulator.log")
 			});
-			if (!(await waitForBoot(selected.serial, 24e4, { commandTimeoutMs: 5e3 })).ok || getAvdNameForSerial(selected.serial) !== avdName || androidDeviceAbi(selected.serial) !== selected.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
+			const boot = await waitForBoot(selected.serial, 24e4, { commandTimeoutMs: 5e3 });
+			if (!boot.ok) {
+				const { sysBoot, devBoot, bootAnim, packageManager } = boot.diagnostic ?? {};
+				throw new Error(`Hosted Android boot could not be verified for its exact owned AVD. Diagnostic: ${JSON.stringify({
+					sysBoot,
+					devBoot,
+					bootAnim,
+					packageManager
+				})}`);
+			}
+			if (getAvdNameForSerial(selected.serial) !== avdName || androidDeviceAbi(selected.serial) !== selected.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
 			return {
 				state: "ready",
 				device: selected
@@ -798,7 +808,17 @@ async function runHostedAndroidDevice(mode, request, app) {
 				openViewer: false,
 				logFile: join(home, "emulator.log")
 			});
-			if (!(await waitForBoot(device.serial, 24e4, { commandTimeoutMs: 5e3 })).ok || getAvdNameForSerial(device.serial) !== device.avdName || androidDeviceAbi(device.serial) !== device.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
+			const boot = await waitForBoot(device.serial, 24e4, { commandTimeoutMs: 5e3 });
+			if (!boot.ok) {
+				const { sysBoot, devBoot, bootAnim, packageManager } = boot.diagnostic ?? {};
+				throw new Error(`Hosted Android boot could not be verified for its exact owned AVD. Diagnostic: ${JSON.stringify({
+					sysBoot,
+					devBoot,
+					bootAnim,
+					packageManager
+				})}`);
+			}
+			if (getAvdNameForSerial(device.serial) !== device.avdName || androidDeviceAbi(device.serial) !== device.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
 			await resetAdoptedAvd(device.avdName, device.serial, "");
 			removeHostedAppData(home, { keepBlobs: true });
 			return {

package/dist/device-ios-CRUqPxKw.mjs

@@ -0,0 +1,413 @@
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.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-D0LhTY3S.mjs";
+import { T as iosSimSlimProfileSetting } from "./settings-Bbztm4oV.mjs";
+import { S as workspaceId } from "./workspace-state-CSIFuuDa.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { dt as parkedMaxSetting, ft as readParked, mt as selectParked, ot as adoptParked, st as dropParked } from "./android-BsYNR81W.mjs";
+import { S as teardownParkedIosSim } from "./workspaces-D2xSHBDY.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-C2lvoPsb.mjs";
+import { A as configuredIosSimulatorViewer, C as resetIosKeychain, E as resolveOwnedIosSim, M as hostMemoryPressureAdvice, N as memoryCulpritsUnder, P as readHostMemoryPressure, S as renameIosSim, T as resolveIosCreation, _ as ownedSimName, a as createOwnedIosSim, d as listAllIosSims, m as listIosRuntimes, n as bootIosSim, p as listIosDeviceTypes, u as iosSimulatorFailureAdvice, w as resetIosPrivacy, y as parseRuntimeVersion } from "./ios-CXLIUxXJ.mjs";
+import { a as deviceTypeMismatch, c as runtimeMismatch, n as DeviceAdmissionRefusal, p as withDeviceBootAdmission } from "./device-capacity-Ca_ke1LE.mjs";
+import chalk from "chalk";
+//#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 pressure = readHostMemoryPressure();
+	const memoryAdvice = hostMemoryPressureAdvice(pressure, memoryCulpritsUnder(pressure));
+	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 { ensureOwnedIosDevice as i, clearIosAdoptionPending as n, ensureIosBooted as r, IosDeviceMismatchError as t };