stim 1.33.0 → 1.35.0

package/dist/device-ios-DFaYFdar.mjs

@@ -1,716 +0,0 @@
-import { D as ownership_claim_exports, l as cancellableSleep, n as isTimeoutError, p as withWorkspaceProcessLock, t as getExecutor } from "./exec-CGuDzt40.mjs";
-import { D as workspaceId$1, k as workspaceLogsDir$1 } from "./workspace-state-BdZ-QgmB.mjs";
-import { l as phaseLine } from "./command-output-DWI9tGPU.mjs";
-import { T as setDevice, a as clearDevice, d as getConfigDir, ft as deviceSlotPlatforms, ht as projectDeviceSlots, k as withConfigLockAsync$1, v as loadConfig$1, w as saveConfig } from "./config-BW0fAtoK.mjs";
-import { D as iosSimSlimProfileSetting, E as iosSimSlimDefaultSetting } from "./settings-B5IBDfTx.mjs";
-import { Ct as selectParked, bt as parkedMaxSetting, gt as dropParked, ht as adoptParked, xt as readParked } from "./android-Iq0M2t2d.mjs";
-import { i as createNdjsonWriter } from "./ndjson-CrjIsGzw.mjs";
-import { _t as teardownParkedIosSim, ht as teardownOwnedIosSim } from "./workspaces-B3ahAHZc.mjs";
-import { A as springBoardRunning, B as reportMemoryCulprits, C as renameIosSim, D as resolveOwnedIosSim, E as resolveIosCreation, F as hostMemoryPressureAdvice, M as waitForSpringBoard, N as configuredIosSimulatorViewer, R as readHostMemoryPressure, S as readSpringBoardPid, T as resetIosPrivacy, _ as ownedSimName, a as createOwnedIosSim, d as listAllIosSims, f as listAllIosSimsAsync, h as listIosRuntimesAsync, n as bootIosSim, p as listIosDeviceTypesAsync, u as iosSimulatorFailureAdvice, w as resetIosKeychain, y as parseRuntimeVersion } from "./ios-BdZdNsAj.mjs";
-import { _ as withDeviceBootAdmission, f as runtimeMismatch, l as deviceTypeMismatch, n as DeviceAdmissionRefusal } from "./device-capacity-BAkETfIl.mjs";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { LOG_ROTATE_BYTES, ambientContext } from "@stim-cli/core";
-import { isJsonObject } from "@stim-cli/core/state";
-import chalk from "chalk";
-import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
-//#region src/devices/springboard-crash-reports.ts
-const REPORT_WINDOW_MS = 6e5;
-const MAX_CANDIDATES = 100;
-const MAX_STORED = 40;
-const MAX_REPORT_BYTES = 1048576;
-const MAX_COPIED_BYTES = 8388608;
-function selectSpringBoardReports(entries, udid, sinceMs) {
-	const owner = `.${udid}`.toLowerCase();
-	return entries.flatMap(({ name, text }) => {
-		if (!/^SpringBoard-.+\.ips$/.test(name)) return [];
-		try {
-			const report = JSON.parse(text.slice(text.indexOf("\n") + 1));
-			if (!isJsonObject(report)) return [];
-			const { coalitionName, captureTime } = report;
-			const capturedAt = Date.parse(typeof captureTime === "string" ? captureTime : "");
-			return typeof coalitionName === "string" && coalitionName.toLowerCase().endsWith(owner) && capturedAt >= sinceMs ? [name] : [];
-		} catch {
-			return [];
-		}
-	});
-}
-/**
-* Copies this simulator's recent SpringBoard crash reports from DiagnosticReports and its Retired folder into
-* `destDir`, which keeps at most 40 of them. The source folders are only read; macOS deletes their reports after
-* about two days. Returns the matching reports now in `destDir`, how many matched but did not fit its limits, and
-* the message of a write that failed.
-*/
-async function copySpringBoardCrashReports({ udid, destDir, now = Date.now(), home = homedir() }) {
-	const since = now - REPORT_WINDOW_MS;
-	const reportsDir = join(home, "Library/Logs/DiagnosticReports");
-	const candidates = /* @__PURE__ */ new Map();
-	for (const directory of [reportsDir, join(reportsDir, "Retired")]) {
-		let names;
-		try {
-			names = await readdir(directory);
-		} catch (error) {
-			if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
-			throw error;
-		}
-		for (const name of names) {
-			if (!/^SpringBoard-.+\.ips$/.test(name) || candidates.has(name)) continue;
-			try {
-				const path = join(directory, name);
-				const { mtimeMs, size } = await stat(path);
-				if (mtimeMs >= since && size <= MAX_REPORT_BYTES) candidates.set(name, {
-					path,
-					mtimeMs
-				});
-			} catch {}
-		}
-	}
-	const newest = [...candidates].toSorted((a, b) => b[1].mtimeMs - a[1].mtimeMs).slice(0, MAX_CANDIDATES);
-	const entries = [];
-	for (const [name, { path }] of newest) try {
-		entries.push({
-			name,
-			text: await readFile(path, "utf8")
-		});
-	} catch {}
-	const matching = selectSpringBoardReports(entries, udid, since);
-	if (matching.length === 0) return {
-		files: [],
-		dropped: 0
-	};
-	await mkdir(destDir, {
-		recursive: true,
-		mode: 448
-	});
-	const present = new Set(await readdir(destDir));
-	let stored = [...present].filter((name) => /^SpringBoard-.+\.ips$/.test(name)).length;
-	let copiedBytes = 0;
-	const files = [];
-	for (const { name, text } of entries) {
-		if (!matching.includes(name)) continue;
-		if (present.has(name)) {
-			files.push(name);
-			continue;
-		}
-		const bytes = Buffer.byteLength(text);
-		if (stored >= MAX_STORED || copiedBytes + bytes > MAX_COPIED_BYTES) continue;
-		try {
-			await writeFile(join(destDir, name), text, {
-				flag: "wx",
-				mode: 384
-			});
-		} catch (error) {
-			if (error instanceof Error && "code" in error && error.code === "EEXIST") {
-				files.push(name);
-				continue;
-			}
-			await rm(join(destDir, name), { force: true }).catch(() => {});
-			return {
-				files,
-				dropped: 0,
-				failure: error instanceof Error ? error.message : String(error)
-			};
-		}
-		stored++;
-		copiedBytes += bytes;
-		files.push(name);
-	}
-	return {
-		files,
-		dropped: matching.length - files.length
-	};
-}
-//#endregion
-//#region src/engine/ios-boot-log.ts
-function iosBootRecorder(root, slot, udid) {
-	return (event, { level = "info", ...fields }) => {
-		try {
-			const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "device.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
-			writer.write({
-				src: "device",
-				platform: "ios",
-				level,
-				event,
-				deviceId: udid,
-				...slot && slot !== "default" ? { slot } : {},
-				...fields
-			});
-			writer.close();
-		} catch {}
-	};
-}
-//#endregion
-//#region src/engine/device-ios.ts
-function recordBootPhase(record, udid, origin) {
-	return (event) => {
-		const pid = "pid" in event ? event.pid : void 0;
-		const boot = event.phase === "boot_requested" ? origin : void 0;
-		record("ios_boot", {
-			phase: event.phase,
-			...pid === void 0 ? {} : { pid },
-			...boot === void 0 ? {} : { boot },
-			msg: `ios boot ${udid}: ${event.phase}${pid === void 0 ? "" : ` pid ${pid}`}${boot === void 0 ? "" : ` (${boot})`}`
-		});
-	};
-}
-function startIosBoot(udid, configure, label, out, simulatorApp, root, slot, origin, deviceSlotWait) {
-	const done = withDeviceBootAdmission({
-		platform: "ios",
-		key: udid
-	}, async () => {
-		out(chalk.dim(phaseLine("device", `booting ${label} (${udid})`)));
-		await bootIosSim(udid, {
-			label,
-			out,
-			simulatorApp,
-			env: ambientContext()?.env,
-			onPhase: recordBootPhase(iosBootRecorder(root, slot, udid), udid, origin)
-		});
-		await configure();
-		await muteBootedSimulator(udid, out);
-	}, {
-		...deviceSlotWait,
-		root,
-		out
-	});
-	done.catch(() => {});
-	return {
-		udid,
-		done
-	};
-}
-const SPRINGBOARD_MUTE_WAIT_MS = 6e4;
-async function muteBootedSimulator(udid, out) {
-	try {
-		const springBoard = await waitForSpringBoard(udid, Date.now() + SPRINGBOARD_MUTE_WAIT_MS);
-		if (springBoard.state === "unreadable") throw new Error(springBoard.reason);
-		if (springBoard.state === "timed-out") throw new Error(`SpringBoard did not finish starting within ${SPRINGBOARD_MUTE_WAIT_MS / 1e3}s.`);
-		const response = JSON.parse(await getExecutor().runFileAsync("xcrun", [
-			"devicectl",
-			"device",
-			"settings",
-			"audio",
-			"--device",
-			udid,
-			"--volume",
-			"0",
-			"--json-output",
-			"-"
-		], { timeoutMs: 3e4 }));
-		if (!isJsonObject(response) || !isJsonObject(response.info) || response.info.outcome !== "success" || !isJsonObject(response.result) || typeof response.result.deviceIdentifier !== "string" || response.result.deviceIdentifier.toUpperCase() !== udid.toUpperCase() || response.result.volume !== 0) throw new Error("Xcode did not confirm volume zero for this simulator.");
-		out(chalk.dim(phaseLine("device", "simulator muted; turn on Sound in its Stim Desktop options")));
-	} catch (error) {
-		out(chalk.yellow(phaseLine("device", `Could not mute this simulator: ${error instanceof Error ? error.message : String(error)}`)));
-	}
-}
-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);
-	if (memoryAdvice) out(chalk.yellow(phaseLine("memory", memoryAdvice)));
-	reportMemoryCulprits(pressure, (named) => out(chalk.yellow(phaseLine("memory", named))));
-	const simslimProfile = iosSimSlimProfileSetting(settings, settingsRoot);
-	const simslimDefault = iosSimSlimDefaultSetting(settings);
-	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 = await listIosDeviceTypesAsync({ snapshot: simSnapshot });
-				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, await listIosRuntimesAsync({ snapshot: simSnapshot })) : 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.simslimApplied ? { simslimApplied: record.simslimApplied } : {},
-					...record.adopted ? { adopted: true } : {},
-					...record.adoptionPending ? { adoptionPending: true } : {},
-					...record.parkedCacheKey ? { parkedCacheKey: record.parkedCacheKey } : {},
-					...record.schemeApprovals ? { schemeApprovals: record.schemeApprovals } : {}
-				};
-				const configure = async (freshBoot) => {
-					if (record.adoptionPending) await resetAdoptedSim(sim.udid, out);
-					return configureOwnedIosSim({
-						record: updated,
-						projectPath,
-						slot,
-						profile: simslimProfile,
-						slimByDefault: simslimDefault,
-						freshBoot,
-						out,
-						reconcileIosSimulator
-					});
-				};
-				const facts = {
-					deviceType: model.model,
-					runtime: model.runtime
-				};
-				if (sim.state !== "Booted") return {
-					...updated,
-					booting: startIosBoot(sim.udid, () => configure(true), name, out, flags.simulatorApp, projectPath, slot, record.adoptionPending ? "adopted" : "existing", flags.deviceSlotWait),
-					...facts
-				};
-				const { record: configured, rebooted } = await configure(false);
-				if (rebooted) await muteBootedSimulator(sim.udid, out);
-				return {
-					...configured,
-					...facts,
-					booted: sim.udid
-				};
-			}
-		} else {
-			const sim = (await listAllIosSimsAsync()).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;
-			}
-		}
-		await withConfigLockAsync$1(() => {
-			const current = deviceSlotPlatforms(loadConfig$1()?.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 = await 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 () => {
-			await resetAdoptedSim(adopted.deviceUdid, out);
-			await configureOwnedIosSim({
-				record: adopted,
-				projectPath,
-				slot,
-				profile: simslimProfile,
-				slimByDefault: simslimDefault,
-				freshBoot: true,
-				out,
-				reconcileIosSimulator
-			});
-		}, adopted.deviceName, out, flags.simulatorApp, projectPath, slot, "adopted", flags.deviceSlotWait);
-		return {
-			...adopted,
-			booting,
-			deviceType: choice.deviceType,
-			runtime: choice.runtime
-		};
-	}
-	const created = await withIosDeviceNameLock(async () => {
-		const suffix = ownedIosNameSuffix(label, {
-			model: choice.deviceType,
-			runtime: choice.runtime
-		}, projectPath, void 0, await listAllIosSimsAsync({ includeUnavailable: true }));
-		const result = await createOwnedIosSim(label, { suffix }, choice);
-		await withConfigLockAsync$1(() => 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,
-		slimByDefault: simslimDefault,
-		freshBoot: true,
-		out,
-		reconcileIosSimulator
-	}), created.name, out, flags.simulatorApp, projectPath, slot, "created", 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) {
-	const names = new Set(listed.filter((sim) => sim.udid !== udid).map((sim) => sim.name));
-	for (const project of Object.values(loadConfig$1()?.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$1(projectPath)}${attempt ? `-${attempt}` : ""}`;
-	return suffix;
-}
-function ownedIosName(sim, label, model, projectPath, listed) {
-	return ownedSimName(label, model, ownedIosNameSuffix(label, model, projectPath, sim.udid, listed));
-}
-async function renameToOwnedName(sim, label, model, projectPath) {
-	const wanted = ownedIosName(sim, label, model, projectPath, await listAllIosSimsAsync({ includeUnavailable: true }));
-	if (sim.name === wanted) return wanted;
-	try {
-		await renameIosSim(sim.udid, wanted);
-		return wanted;
-	} catch {
-		return sim.name;
-	}
-}
-async function resetAdoptedSim(udid, out) {
-	out(chalk.dim(phaseLine("device", `resetting privacy grants and the keychain on ${udid}`)));
-	await resetIosPrivacy(udid);
-	await resetIosKeychain(udid);
-}
-async 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((await listAllIosSimsAsync({ 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 ? await teardownParkedIosSim(parked.udid, { label: parked.name }) : null;
-			if (sim ? result?.status === "torn-down" : await 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, [...listed.values()]));
-		const device = {
-			deviceUdid: parked.udid,
-			owned: true,
-			deviceName: name,
-			adopted: true,
-			adoptionPending: true,
-			...parked.simslimManaged ? { simslimManaged: true } : {},
-			...parked.cacheKey ? { parkedCacheKey: parked.cacheKey } : {}
-		};
-		const adopted = await adoptParked({
-			platform: "ios",
-			projectPath,
-			slot,
-			udid: parked.udid,
-			device
-		});
-		if (!adopted) continue;
-		try {
-			await renameIosSim(parked.udid, name);
-		} catch {}
-		return adopted.schemeApprovals && adopted.schemeApprovals.length > 0 ? {
-			...device,
-			schemeApprovals: adopted.schemeApprovals
-		} : device;
-	}
-	return null;
-}
-function clearIosAdoptionPending(projectPath, slot = "default") {
-	return withConfigLockAsync$1(() => {
-		const cfg = loadConfig$1();
-		const ios = deviceSlotPlatforms(cfg?.projects?.[projectPath], slot)?.ios;
-		if (!cfg || !ios?.adoptionPending) return;
-		delete ios.adopted;
-		delete ios.adoptionPending;
-		delete ios.parkedCacheKey;
-		saveConfig(cfg);
-	});
-}
-function simslimProfileIdentity(profile, slimByDefault) {
-	if (profile) return `profile:${createHash("sha256").update(readFileSync(profile)).digest("hex")}`;
-	return slimByDefault ? "default" : null;
-}
-async function startedSpringBoardPid(udid) {
-	const springBoard = await waitForSpringBoard(udid, Date.now() + SPRINGBOARD_MUTE_WAIT_MS);
-	return springBoard.state === "started" ? springBoard.pid : null;
-}
-async function configureOwnedIosSim({ record, projectPath, slot, profile, slimByDefault, freshBoot, out, reconcileIosSimulator }) {
-	const identity = simslimProfileIdentity(profile, slimByDefault);
-	const slimConfigured = identity !== null || Boolean(record.simslimManaged);
-	const applied = record.simslimApplied;
-	const springBoardBefore = slimConfigured ? await readSpringBoardPid(record.deviceUdid) : null;
-	if (identity !== null && record.simslimManaged && !freshBoot && applied?.profile === identity && springBoardBefore !== null && springBoardBefore === applied.springBoardPid) {
-		await withConfigLockAsync$1(() => setDevice(projectPath, "ios", { ...record }, slot));
-		return {
-			record,
-			rebooted: false
-		};
-	}
-	if (profile) out(chalk.dim(phaseLine("device", `applying the SimSlim profile to ${record.deviceUdid}`)));
-	else if (slimByDefault) out(chalk.dim(phaseLine("device", `applying SimSlim's default services 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 (identity !== null && !record.simslimManaged || applied) {
-		const { simslimApplied: _applied, ...rest } = record;
-		const pending = identity !== null ? {
-			...rest,
-			simslimManaged: true
-		} : rest;
-		await withConfigLockAsync$1(() => setDevice(projectPath, "ios", pending, slot));
-		record = pending;
-	}
-	const result = await reconcileIosSimulator({
-		context: ambientContext(),
-		udid: record.deviceUdid,
-		profile,
-		slimByDefault,
-		previouslyManaged,
-		out
-	});
-	const updated = { ...record };
-	if (result.managed) updated.simslimManaged = true;
-	else delete updated.simslimManaged;
-	const springBoardAfter = slimConfigured ? await startedSpringBoardPid(record.deviceUdid) : null;
-	if (result.managed && !result.notInstalled && identity !== null && springBoardAfter !== null) updated.simslimApplied = {
-		profile: identity,
-		springBoardPid: springBoardAfter
-	};
-	await withConfigLockAsync$1(() => setDevice(projectPath, "ios", updated, slot));
-	const rebooted = slimConfigured && springBoardAfter !== springBoardBefore;
-	if (rebooted && !result.notInstalled) iosBootRecorder(projectPath, slot, record.deviceUdid)("ios_boot", {
-		phase: "simslim_reboot",
-		pidBefore: springBoardBefore,
-		pidAfter: springBoardAfter,
-		msg: `ios boot ${record.deviceUdid}: simslim_reboot (SpringBoard pid ${springBoardBefore ?? "unknown"} to ${springBoardAfter ?? "unknown"})`
-	});
-	return {
-		record: updated,
-		rebooted
-	};
-}
-const SPRINGBOARD_RESPAWN_POLLS = 20;
-const SPAWN_STALL_TOLERANCE_MS = 18e4;
-async function ensureIosBooted(args) {
-	const { springBoardDown, ...first } = await bootOwnedIosSim(args);
-	const { device, projectPath, out } = args;
-	const udid = device?.deviceUdid;
-	if (!springBoardDown || !device || !udid) return first;
-	out(chalk.yellow(phaseLine("device", `SpringBoard is not running on ${udid}; restarting the simulator once`)));
-	const record = iosBootRecorder(projectPath, args.slot, udid);
-	await preserveSpringBoardReports(record, udid, projectPath);
-	const stopped = await teardownOwnedIosSim(udid, { workspace: projectPath });
-	if (stopped.status !== "torn-down") return {
-		...first,
-		reason: `${first.reason} The restart did not run: ${stopped.reason ?? stopped.status}.`
-	};
-	record("ios_boot", {
-		phase: "restart",
-		level: "warn",
-		msg: `ios boot ${udid}: restart (SpringBoard is not running after boot; restarting once)`
-	});
-	const { booted: _booted, booting: _booting, ...unbooted } = device;
-	const { springBoardDown: stillDown, ...second } = await bootOwnedIosSim({
-		...args,
-		device: unbooted,
-		origin: "restart"
-	});
-	if (stillDown) await preserveSpringBoardReports(record, udid, projectPath);
-	return stillDown ? {
-		...second,
-		reason: `${second.reason} Stim already restarted the simulator once, so it did not restart it again.`
-	} : second;
-}
-async function preserveSpringBoardReports(record, udid, root) {
-	const dir = workspaceLogsDir$1(root);
-	try {
-		const { files, dropped, failure } = await copySpringBoardCrashReports({
-			udid,
-			destDir: dir
-		});
-		const limit = dropped ? `; ${dropped} more matched but exceeded the copy limits` : "";
-		record("springboard_crash_reports", {
-			level: files.length || dropped || failure ? "warn" : "info",
-			files,
-			dropped,
-			...failure ? { failure } : {},
-			dir,
-			msg: failure ? `could not copy a SpringBoard crash report for ${udid} (${files.length} copied before it): ${failure}` : files.length ? `copied ${files.length} SpringBoard crash report(s) for ${udid} to ${dir}: ${files.join(", ")}${limit}` : dropped ? `${dropped} SpringBoard crash report(s) for ${udid} matched but exceeded the copy limits` : `no SpringBoard crash report for ${udid} from the last 10 minutes`
-		});
-	} catch (error) {
-		record("springboard_crash_reports", {
-			level: "warn",
-			files: [],
-			dropped: 0,
-			failure: error instanceof Error ? error.message : String(error),
-			dir,
-			msg: `could not copy SpringBoard crash reports for ${udid}: ${error instanceof Error ? error.message : String(error)}`
-		});
-	}
-}
-async function bootOwnedIosSim({ device, projectPath, slot, origin, deviceSlotWait, simulatorApp, timeoutMs, pollMs, out }) {
-	const udid = device?.deviceUdid;
-	if (!udid) return {
-		failed: true,
-		reason: "No iOS simulator is recorded for this project."
-	};
-	const onPhase = recordBootPhase(iosBootRecorder(projectPath, slot, udid), udid, origin ?? (device.adoptionPending ? "adopted" : "existing"));
-	const openViewer = async () => {
-		await configuredIosSimulatorViewer(simulatorApp, ambientContext()?.env).open(udid);
-		onPhase({ phase: "viewer_opened" });
-	};
-	const ready = async () => {
-		try {
-			const stallDeadline = Date.now() + SPAWN_STALL_TOLERANCE_MS;
-			const listSpringBoard = async () => {
-				for (;;) try {
-					return await getExecutor().runFileAsync("xcrun", [
-						"simctl",
-						"spawn",
-						udid,
-						"launchctl",
-						"list"
-					], { timeoutMs: 3e4 });
-				} catch (error) {
-					if (!isTimeoutError(error) || Date.now() >= stallDeadline) throw error;
-					const sims = await listAllIosSimsAsync().catch(() => null);
-					if (sims && sims.find((s) => s.udid === udid)?.state !== "Booted") throw error;
-				}
-			};
-			let listing = await listSpringBoard();
-			for (let poll = 0; !springBoardRunning(listing) && poll < SPRINGBOARD_RESPAWN_POLLS; poll++) {
-				await cancellableSleep(pollMs);
-				listing = await listSpringBoard();
-			}
-			if (!springBoardRunning(listing)) return {
-				failed: true,
-				springBoardDown: true,
-				reason: `Simulator ${udid} reports Booted, but SpringBoard (the system shell) is not running, so apps cannot launch. Run \`stim stop\`, then \`stim ios\` again. If it repeats, look for SpringBoard crash reports in ~/Library/Logs/DiagnosticReports.`
-			};
-			return {
-				ok: true,
-				udid
-			};
-		} catch (error) {
-			return {
-				failed: true,
-				reason: `Simulator ${udid} failed its process-spawn readiness check: ${error?.message || error}. ${await 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 ? await ready() : null;
-	if (readiness?.ok) {
-		if (simulatorApp !== void 0) await openViewer();
-		return readiness;
-	}
-	let resolved;
-	try {
-		resolved = resolveOwnedIosSim(udid, await listAllIosSimsAsync());
-	} 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 ?? await ready();
-		if (result.ok && simulatorApp !== void 0) await openViewer();
-		return result;
-	}
-	const bootDeadline = Date.now() + timeoutMs;
-	try {
-		await withDeviceBootAdmission({
-			platform: "ios",
-			key: udid
-		}, async () => {
-			out(chalk.dim(phaseLine("device", `booting ${sim.name} (${udid})`)));
-			await bootIosSim(udid, {
-				timeoutMs,
-				label: sim.name,
-				out,
-				simulatorApp,
-				env: ambientContext()?.env,
-				onPhase
-			});
-			await muteBootedSimulator(udid, out);
-		}, {
-			...deviceSlotWait,
-			root: projectPath,
-			out
-		});
-	} catch (e) {
-		return bootFailure(udid, e);
-	}
-	const deadline = Math.max(bootDeadline, Date.now() + 2 * pollMs);
-	while (Date.now() < deadline) {
-		await cancellableSleep(pollMs);
-		let state = null;
-		try {
-			state = (await listAllIosSimsAsync({ 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}`
-	};
-}
-//#endregion
-export { muteBootedSimulator as a, ensureOwnedIosDevice as i, clearIosAdoptionPending as n, ensureIosBooted as r, IosDeviceMismatchError as t };