stim 1.8.0 → 1.10.0

package/dist/guide-status-CWvti2Lg.mjs

@@ -0,0 +1,125 @@
+import { f as getProject, u as getConfigDir, w as upsertProject } from "./config-BEq0Qw_a.mjs";
+import { n as appProjectProblem } from "./project-BXZzOABt.mjs";
+import { t as compareStimVersions } from "./stim-installations-CINXy_su.mjs";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/guide-status.ts
+const DAY_MS = 864e5;
+const DOCTOR_STALE_MS = 7 * DAY_MS;
+const UPDATE_CHECK_INTERVAL_MS = DAY_MS;
+const UPDATE_CHECK_TIMEOUT_MS = 2e3;
+const LATEST_URL = "https://registry.npmjs.org/stim/latest";
+const PLATFORMS = ["ios", "android"];
+function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date()) {
+	const run = {
+		at: now.toISOString(),
+		version
+	};
+	try {
+		if (appProjectProblem(projectRoot)) return;
+		upsertProject(projectRoot, (existing) => {
+			const doctorRuns = { ...existing.doctorRuns };
+			for (const target of platform ? [platform] : PLATFORMS) doctorRuns[target] = run;
+			return { doctorRuns };
+		});
+	} catch {}
+}
+function doctorDueReason(record, running, now) {
+	const at = record ? Date.parse(record.at) : NaN;
+	if (!record || Number.isNaN(at)) return "never run";
+	if (record.version !== running) return `last run with stim ${record.version}`;
+	const age = now.getTime() - at;
+	if (age > DOCTOR_STALE_MS) return `last run ${Math.floor(age / DAY_MS)} days ago`;
+	return null;
+}
+function updateCacheFile() {
+	return join(getConfigDir(), "update-check.json");
+}
+function readUpdateCache() {
+	try {
+		const parsed = JSON.parse(readFileSync(updateCacheFile(), "utf-8"));
+		if (typeof parsed?.checkedAt !== "string") return null;
+		return {
+			checkedAt: parsed.checkedAt,
+			latest: typeof parsed.latest === "string" ? parsed.latest : null
+		};
+	} catch {
+		return null;
+	}
+}
+function writeUpdateCache(cache) {
+	const target = updateCacheFile();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		mkdirSync(getConfigDir(), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(cache)}\n`);
+		renameSync(tmp, target);
+	} catch {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+	}
+}
+async function fetchLatest(fetchImpl) {
+	const res = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
+	if (!res.ok) return null;
+	const body = await res.json();
+	return typeof body.version === "string" ? body.version : null;
+}
+async function checkForUpdate(running, { now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch } = {}) {
+	if (process.env.STIM_NO_UPDATE_CHECK) return null;
+	const cached = readUpdateCache();
+	const checkedAt = cached ? Date.parse(cached.checkedAt) : NaN;
+	let latest = cached?.latest ?? null;
+	if (Number.isNaN(checkedAt) || now.getTime() - checkedAt > UPDATE_CHECK_INTERVAL_MS) {
+		try {
+			latest = await fetchLatest(fetchImpl);
+		} catch {
+			latest = null;
+		}
+		writeUpdateCache({
+			checkedAt: now.toISOString(),
+			latest
+		});
+	}
+	if (!latest) return null;
+	const comparison = compareStimVersions(latest, running);
+	return comparison !== null && comparison > 0 ? latest : null;
+}
+function renderGuideStatus({ running, doctor, latest }) {
+	const lines = [];
+	if (doctor.length) {
+		const named = doctor.map((due) => `${due.platform} (${due.reason})`).join(" and ");
+		const command = doctor.length === 1 ? `stim doctor --platform ${doctor[0]?.platform}` : "stim doctor";
+		lines.push(`  Doctor is due for ${named}.`, `  Run before native work:  ${command}`);
+	}
+	if (latest) lines.push(`  stim ${latest} is available (running ${running}):  npm install -g stim@latest`);
+	if (!lines.length) return null;
+	return ["STATUS", ...lines].join("\n");
+}
+async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
+	const doctor = [];
+	if (projectRoot && !appProjectProblem(projectRoot)) {
+		let runs = null;
+		try {
+			runs = getProject(projectRoot)?.doctorRuns ?? {};
+		} catch {}
+		if (runs) for (const platform of PLATFORMS) {
+			const reason = doctorDueReason(runs[platform], running, now);
+			if (reason) doctor.push({
+				platform,
+				reason
+			});
+		}
+	}
+	return renderGuideStatus({
+		running,
+		doctor,
+		latest: await checkForUpdate(running, {
+			now,
+			fetch: fetchImpl
+		})
+	});
+}
+//#endregion
+export { recordDoctorRun as n, guideStatus as t };

package/dist/idle-DpRLp5lj.mjs

@@ -0,0 +1,157 @@
+import { H as projectDeviceSlots } from "./config-BEq0Qw_a.mjs";
+import { m as readWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { o as formatLongDuration } from "./command-output-D5z2_bcF.mjs";
+import { c as createActivityReader, l as idleForMs, o as parseActiveBuild, r as activeBuildState, t as ACTIVE_BUILD_KEY } from "./build-progress-BXx-ZBe4.mjs";
+import { N as ownedAvdSerialResolver } from "./android-787HhP5w.mjs";
+import { d as teardownOwnedAvd, f as teardownOwnedIosSim } from "./ownership-DZjdx8Gq.mjs";
+import chalk from "chalk";
+//#region src/commands/gc/idle.ts
+function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
+	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
+	const dead = new Set(deadProjects);
+	const found = [];
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		if (dead.has(project)) continue;
+		for (const { slot, platforms } of projectDeviceSlots(record)) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
+				kind: "ios",
+				id: ios.deviceUdid,
+				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "ios",
+					id: ios.deviceUdid,
+					slot,
+					workspace: project
+				})
+			});
+			const android = platforms.android;
+			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
+			if (android?.avdName && serial) found.push({
+				kind: "android",
+				id: android.avdName,
+				name: android.avdName,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "android",
+					id: serial,
+					slot,
+					workspace: project
+				})
+			});
+		}
+	}
+	return found;
+}
+function findIdleDevices({ buildInProgress, now, ...inputs }) {
+	return findOwnedDeviceActivity(inputs).filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
+		kind,
+		id,
+		name,
+		project,
+		slot,
+		lastActivityAt: activity.lastActivityAt ?? null,
+		idleForMs: idleForMs(activity, now),
+		buildInProgress: buildInProgress(project)
+	}));
+}
+function idleShutdownCandidates(devices, idleMs) {
+	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
+}
+function parseIdleDuration(value) {
+	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
+	if (!match) return null;
+	const unit = {
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	return Number(match[1]) * unit;
+}
+function workspaceBuildInProgress(project) {
+	const record = parseActiveBuild(readWorkspaceState(project)?.[ACTIVE_BUILD_KEY]);
+	if (!record) return false;
+	try {
+		return activeBuildState(record.claim) !== "stale";
+	} catch {
+		return true;
+	}
+}
+function deviceActivityInputs(config, sims, now) {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return {
+		config,
+		sims,
+		readActivity: createActivityReader({ now }),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
+	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
+}
+function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
+	return findIdleDevices({
+		...deviceActivityInputs(config, sims, now),
+		deadProjects,
+		now,
+		buildInProgress: workspaceBuildInProgress
+	});
+}
+function idleDeviceLines(devices) {
+	if (devices.length === 0) return [];
+	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
+		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
+		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
+		const build = d.buildInProgress ? ", build in progress" : "";
+		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
+	})];
+}
+function shutDownIdleDevices(devices, idleMs, recollect) {
+	const candidates = idleShutdownCandidates(devices, idleMs);
+	const shutDown = [];
+	if (candidates.length === 0) {
+		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
+		return {
+			failures: 0,
+			shutDown
+		};
+	}
+	const fresh = idleShutdownCandidates(recollect(), idleMs);
+	let failures = 0;
+	for (const device of candidates) {
+		const what = `${device.kind} ${device.name}`;
+		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
+		if (!current) {
+			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
+			continue;
+		}
+		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
+			projectPath: device.project,
+			slot: device.slot
+		} });
+		if (outcome.status === "torn-down") {
+			shutDown.push(device);
+			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
+		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
+		else if (outcome.status === "skipped") console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
+		else {
+			failures++;
+			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
+		}
+	}
+	return {
+		failures,
+		shutDown
+	};
+}
+//#endregion
+export { parseIdleDuration as a, idleShutdownCandidates as i, collectOwnedDeviceActivity as n, shutDownIdleDevices as o, idleDeviceLines as r, workspaceBuildInProgress as s, collectIdleDevices as t };

package/dist/{build-slots-C-oAHRT1.mjs → in-use-CjUluqIX.mjs}

@@ -1,7 +1,14 @@
-import { E as ownership_claim_exports, u as getConfigDir } from "./config-B7iyKWkL.mjs";
-import { a as formatElapsed } from "./command-output-B3ycpsYv.mjs";
-import { readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { f as getProject, k as ownership_claim_exports, u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { O as workspaceDir, m as readWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { r as stopDeclaringSpawnsOn, t as declareSpawnsOn } from "./spawn-claims-CUleC2cM.mjs";
+import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
+import { a as formatElapsed } from "./command-output-D5z2_bcF.mjs";
+import { h as listBuildLocks } from "./device-lease-CbEaIk7b.mjs";
+import { n as managedLockHolders, t as resolveSupervisorTarget } from "./ownership-DZjdx8Gq.mjs";
+import { lstatSync, readdirSync, rmSync, rmdirSync, statSync, unlinkSync } from "node:fs";
+import { realpathSync as realpathSync$1 } from "fs";
+import { resolve } from "path";
+import { join as join$1 } from "node:path";
 //#region src/engine/build-slots.ts
 const SLOT_PREFIX = "slot-";
 const SLOT_LABEL = "build slot";
@@ -12,10 +19,10 @@ function sleepAsync(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function buildSlotsDir() {
-	return join(getConfigDir(), "build-slots");
+	return join$1(getConfigDir(), "build-slots");
 }
 function buildSlotPath(index) {
-	return join(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
+	return join$1(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
 }
 function toRecord(holder) {
 	const details = holder.details;
@@ -58,6 +65,7 @@ function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
 			busy = true;
 			continue;
 		}
+		declareSpawnsOn(attempt.acquired);
 		return {
 			acquired: true,
 			path,
@@ -110,6 +118,7 @@ async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.n
 }
 function releaseBuildSlot(handle) {
 	if (!handle || handle.unlimited) return false;
+	stopDeclaringSpawnsOn(handle.claim);
 	return (0, ownership_claim_exports.releaseClaim)(handle.claim);
 }
 function listBuildSlots() {
@@ -123,7 +132,7 @@ function listBuildSlots() {
 	const slots = [];
 	for (const name of names) {
 		if (!name.startsWith(SLOT_PREFIX)) continue;
-		const path = join(dir, name);
+		const path = join$1(dir, name);
 		try {
 			if (!statSync(path).isDirectory()) continue;
 		} catch {
@@ -148,4 +157,89 @@ function listBuildSlots() {
 	return slots;
 }
 //#endregion
-export { listBuildSlots as n, releaseBuildSlot as r, acquireBuildSlot as t };
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return resolve(p);
+	}
+}
+//#endregion
+//#region src/workspace/in-use.ts
+const NATIVE_RUN = "native-run";
+const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
+function workspaceInUse(root, { supervisor = true, managedLocks = true, nativeRun = true } = {}) {
+	const reasons = [];
+	if (supervisor) {
+		const project = getProject(root);
+		const target = resolveSupervisorTarget({
+			state: readWorkspaceState(root)?.supervisor,
+			record: project?.supervisor,
+			reservedPort: project?.metroPort
+		});
+		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
+		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+	}
+	if (nativeRun) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
+		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
+		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	const self = canonicalPath(root);
+	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
+		if (!entry.alive && !entry.unresolved) continue;
+		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
+	}
+	if (managedLocks) reasons.push(...managedLockHolders(root));
+	return reasons;
+}
+function emptyWorkspaceDir(dir) {
+	if (lstatSync(dir).isSymbolicLink()) {
+		unlinkSync(dir);
+		return;
+	}
+	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join$1(dir, name), {
+		recursive: true,
+		force: true
+	});
+}
+async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
+			const reasons = workspaceInUse(root, {
+				...checks,
+				nativeRun: false
+			});
+			if (reasons.length) return {
+				ran: false,
+				reasons
+			};
+			return {
+				ran: true,
+				value: await fn()
+			};
+		}, {
+			external: true,
+			waitMs: 0,
+			ownerPurpose: purpose
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error)) return {
+			ran: false,
+			reasons: [NATIVE_RUN_HELD]
+		};
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
+			ran: false,
+			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
+		};
+		throw error;
+	} finally {
+		try {
+			const dir = workspaceDir(root);
+			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
+		} catch {}
+	}
+}
+//#endregion
+export { acquireBuildSlot as a, canonicalPath as i, withIdleWorkspace as n, listBuildSlots as o, workspaceInUse as r, releaseBuildSlot as s, emptyWorkspaceDir as t };

package/dist/{ios-BcCiI4TS.mjs → ios-B2Fpqvlb.mjs}

@@ -1,7 +1,9 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { g as loadConfig } from "./config-B7iyKWkL.mjs";
-import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Dl5uKE03.mjs";
-import { existsSync, mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { g as loadConfig$1 } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { J as recordCreatedDevice, K as isStimOwnedSim, q as forgetCreatedDevice } from "./android-787HhP5w.mjs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { IOS_SIMULATOR_APPS } from "@stim-cli/core/state";
 import { dirname, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 //#region src/host-memory.ts
@@ -29,15 +31,22 @@ const OPEN_OPTIONS = {
 	killSignal: "SIGKILL"
 };
 function parseIosSimulatorApp(value, source = "iosSimulatorApp in machine config") {
-	if (value === void 0 || value === "xcode") return "xcode";
-	if (value === "siniulator") return "siniulator";
-	const error = /* @__PURE__ */ new Error(`Invalid ${source}. Use "xcode" or "siniulator".`);
+	if (value === void 0) return "xcode";
+	if (IOS_SIMULATOR_APPS.includes(value)) return value;
+	const error = /* @__PURE__ */ new Error(`Invalid ${source}. Use "xcode", "siniulator", or "stim-desktop".`);
 	Object.assign(error, { code: "STIM_BAD_ARG" });
 	throw error;
 }
 function configuredIosSimulatorViewer(override) {
-	const app = override ?? parseIosSimulatorApp(loadConfig()?.iosSimulatorApp);
+	const app = override ?? parseIosSimulatorApp(loadConfig$1()?.iosSimulatorApp);
 	const exec = getExecutor();
+	if (app === "stim-desktop") return { open: (udid) => {
+		exec.runFileQuiet("open", [
+			"-a",
+			"Stim",
+			`stim-desktop://open?udid=${udid}`
+		], OPEN_OPTIONS);
+	} };
 	if (app === "siniulator") return { open: (udid) => {
 		exec.runFileQuiet("open", [
 			"-a",
@@ -96,17 +105,29 @@ function parseSimctlList(jsonOutput, { includeUnavailable = false } = {}) {
 	}
 	return sims;
 }
+const SIMCTL_CREATE_TIMEOUT_MS = 18e4;
+const SIMCTL_OPTIONS = {
+	timeoutMs: 6e4,
+	killSignal: "SIGKILL"
+};
+const SIMCTL_LIST_ARGS = [
+	"simctl",
+	"list",
+	"devices",
+	"--json"
+];
 function listAllIosSims({ timeoutMs = 3e4, includeUnavailable = false } = {}) {
-	return parseSimctlList(getExecutor().runFile("xcrun", [
-		"simctl",
-		"list",
-		"devices",
-		"--json"
-	], {
+	return parseSimctlList(getExecutor().runFile("xcrun", SIMCTL_LIST_ARGS, {
 		timeoutMs,
 		killSignal: "SIGKILL"
 	}), { includeUnavailable });
 }
+async function listAllIosSimsAsync({ timeoutMs = 3e4 } = {}) {
+	return parseSimctlList(await getExecutor().runFileAsync("xcrun", SIMCTL_LIST_ARGS, {
+		timeoutMs,
+		killSignal: "SIGKILL"
+	}));
+}
 function parseRuntimeVersion(runtimeId) {
 	const m = runtimeId.match(/iOS-(\d+)(?:-(\d+))?$/);
 	if (!m) return runtimeId;
@@ -252,7 +273,7 @@ async function bootIosSim(udid, { timeoutMs = IOS_BOOT_TIMEOUT_MS, attemptMs = B
 	viewer.open(udid);
 }
 function shutdownIosSim(udid) {
-	getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`);
+	getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`, SIMCTL_OPTIONS);
 }
 function listIosDeviceTypes() {
 	const out = getExecutor().runFile("xcrun", [
@@ -349,8 +370,13 @@ function createOwnedIosSim(label, { deviceType, runtime, suffix = "" } = {}, cho
 		model: choice.deviceType,
 		runtime: choice.runtime
 	}, suffix);
+	const udid = getExecutor().run(`xcrun simctl create "${name}" "${choice.deviceTypeId}" "${choice.runtimeId}"`, {
+		timeoutMs: SIMCTL_CREATE_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	}).trim();
+	recordCreatedDevice("ios", udid);
 	return {
-		udid: getExecutor().run(`xcrun simctl create "${name}" "${choice.deviceTypeId}" "${choice.runtimeId}"`).trim(),
+		udid,
 		name,
 		deviceType: choice.deviceType,
 		runtime: choice.runtime
@@ -362,7 +388,14 @@ function renameIosSim(udid, name) {
 		"rename",
 		udid,
 		name
-	]);
+	], SIMCTL_OPTIONS);
+}
+function eraseIosSim(udid) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"erase",
+		udid
+	], SIMCTL_OPTIONS);
 }
 function resetIosPrivacy(udid) {
 	getExecutor().runFile("xcrun", [
@@ -371,7 +404,7 @@ function resetIosPrivacy(udid) {
 		udid,
 		"reset",
 		"all"
-	]);
+	], SIMCTL_OPTIONS);
 }
 function resetIosKeychain(udid) {
 	getExecutor().runFile("xcrun", [
@@ -379,7 +412,7 @@ function resetIosKeychain(udid) {
 		"keychain",
 		udid,
 		"reset"
-	]);
+	], SIMCTL_OPTIONS);
 }
 function uninstallIosApp(udid, bundleId) {
 	getExecutor().runFile("xcrun", [
@@ -387,7 +420,7 @@ function uninstallIosApp(udid, bundleId) {
 		"uninstall",
 		udid,
 		bundleId
-	]);
+	], SIMCTL_OPTIONS);
 }
 function parseUserApps(jsonOutput) {
 	const data = JSON.parse(jsonOutput);
@@ -426,63 +459,18 @@ function listUserApps(udid) {
 		});
 	}
 }
-const CONTAINER_METADATA = ".com.apple.mobile_container_manager.metadata.plist";
-const CLEARED_CONTAINER_DIRS = [
-	"Documents",
-	"Library",
-	"tmp",
-	"SystemData"
-];
-const PLUTIL_TIMEOUT_MS = 1e4;
-function findAppDataContainer(dataPath, bundleId) {
-	const root = join(dataPath, "Containers", "Data", "Application");
-	let entries;
-	try {
-		entries = readdirSync(root);
-	} catch (error) {
-		if (error?.code === "ENOENT") return null;
-		throw error;
-	}
-	const exec = getExecutor();
-	for (const entry of entries) {
-		const dir = join(root, entry);
-		if (exec.runFile("plutil", [
-			"-extract",
-			"MCMMetadataIdentifier",
-			"raw",
-			join(dir, CONTAINER_METADATA)
-		], { timeoutMs: PLUTIL_TIMEOUT_MS }).trim() === bundleId) return dir;
-	}
-	return null;
-}
-function clearAppDataContainer(container) {
-	for (const name of CLEARED_CONTAINER_DIRS) {
-		const dir = join(container, name);
-		let children;
-		try {
-			if (!statSync(dir).isDirectory()) throw new Error(`Expected app data path ${dir} to be a directory.`);
-			children = readdirSync(dir);
-		} catch (error) {
-			if (error?.code === "ENOENT") continue;
-			throw error;
-		}
-		for (const child of children) rmSync(join(dir, child), {
-			recursive: true,
-			force: true
-		});
-	}
-}
 function resolveOwnedIosSim(udid) {
 	const sim = listAllIosSims().find((s) => s.udid === udid);
 	if (!sim) return { missing: true };
-	if (!sim.name?.startsWith("stim-")) return { notOwned: sim.name };
+	if (!isStimOwnedSim(sim)) return { notOwned: sim.name };
 	return { sim };
 }
 function deleteIosSim(udid) {
 	const result = resolveOwnedIosSim(udid);
 	if (result.missing) return;
-	if (result.notOwned) throw new Error(`Refusing to delete simulator "${result.notOwned}" (${udid}): not a Stim-owned sim (name must start with "stim-").`);
-	getExecutor().run(`xcrun simctl delete ${udid}`);
+	if (result.notOwned) throw new Error(`Refusing to delete simulator "${result.notOwned}" (${udid}): not a Stim-owned sim; Stim has no record of creating it.`);
+	getExecutor().run(`xcrun simctl delete ${udid}`, SIMCTL_OPTIONS);
+	forgetCreatedDevice("ios", udid);
 }
 const PARKED_DELETE_TIMEOUT_MS = 3e4;
 function deleteParkedIosSim(udid) {
@@ -491,12 +479,13 @@ function deleteParkedIosSim(udid) {
 		timeoutMs: PARKED_DELETE_TIMEOUT_MS
 	}).find((entry) => entry.udid === udid);
 	if (!sim) return;
-	if (!sim.name.startsWith("stim-")) throw new Error(`Simulator ${udid} is now named "${sim.name}" and is not Stim-owned; refusing to delete it.`);
+	if (!isStimOwnedSim(sim)) throw new Error(`Simulator ${udid} is now named "${sim.name}" and is not Stim-owned; refusing to delete it.`);
 	getExecutor().runFile("xcrun", [
 		"simctl",
 		"delete",
 		udid
 	], { timeoutMs: PARKED_DELETE_TIMEOUT_MS });
+	forgetCreatedDevice("ios", udid);
 }
 function listIosRuntimes() {
 	const out = getExecutor().runFile("xcrun", [
@@ -519,4 +508,4 @@ function listIosRuntimes() {
 	}));
 }
 //#endregion
-export { shutdownIosSim as C, hostMemoryPressureAdvice as D, parseIosSimulatorApp as E, readHostMemoryPressure as O, sanitizeDeviceLabel as S, configuredIosSimulatorViewer as T, renameIosSim as _, deleteIosSim as a, resolveIosCreation as b, iosRuntimeMatches as c, listIosDeviceTypes as d, listIosRuntimes as f, parseRuntimeVersion as g, parkedSimName as h, createOwnedIosSim as i, iosSimulatorFailureAdvice as l, ownedSimName as m, bootIosSim as n, deleteParkedIosSim as o, listUserApps as p, clearAppDataContainer as r, findAppDataContainer as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSims as u, resetIosKeychain as v, uninstallIosApp as w, resolveOwnedIosSim as x, resetIosPrivacy as y };
+export { sanitizeDeviceLabel as C, parseIosSimulatorApp as D, configuredIosSimulatorViewer as E, hostMemoryPressureAdvice as O, resolveOwnedIosSim as S, uninstallIosApp as T, parseSimctlList as _, deleteParkedIosSim as a, resetIosPrivacy as b, iosSimulatorFailureAdvice as c, listIosDeviceTypes as d, listIosRuntimes as f, parseRuntimeVersion as g, parkedSimName as h, deleteIosSim as i, readHostMemoryPressure as k, listAllIosSims as l, ownedSimName as m, bootIosSim as n, eraseIosSim as o, listUserApps as p, createOwnedIosSim as r, iosRuntimeMatches as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSimsAsync as u, renameIosSim as v, shutdownIosSim as w, resolveIosCreation as x, resetIosKeychain as y };