stim 1.9.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/in-use-CjUluqIX.mjs

@@ -0,0 +1,245 @@
+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";
+const SLOT_POLL_MS = 1e3;
+const SLOT_PROGRESS_MS = 3e4;
+const SLOT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildSlotsDir() {
+	return join$1(getConfigDir(), "build-slots");
+}
+function buildSlotPath(index) {
+	return join$1(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		index: typeof details.index === "number" ? details.index : null,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	let refusal = null;
+	let busy = false;
+	for (let index = 0; index < max; index++) {
+		const path = buildSlotPath(index);
+		let attempt;
+		try {
+			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+				root: path,
+				mode: "exclusive",
+				label: SLOT_LABEL,
+				details: {
+					index,
+					projectRoot: root,
+					logFile
+				}
+			});
+		} catch (err) {
+			if (!(0, ownership_claim_exports.isClaimRefusal)(err)) throw err;
+			refusal ??= err;
+			continue;
+		}
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		if (!attempt.acquired) {
+			busy = true;
+			continue;
+		}
+		declareSpawnsOn(attempt.acquired);
+		return {
+			acquired: true,
+			path,
+			index,
+			slot: {
+				pid: attempt.acquired.owner.pid,
+				index,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+	}
+	if (refusal && !busy) throw refusal;
+	return null;
+}
+function slotWaitingLine({ max, elapsedMs }) {
+	return `${"build".padEnd(11)} waiting for a build slot (all ${max} in use, ${formatElapsed(elapsedMs)} elapsed) -- stim guide lifecycle concurrency`;
+}
+async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.now, out = () => {}, sleep = sleepAsync, intervalMs = SLOT_POLL_MS, progressMs = SLOT_PROGRESS_MS, ceilingMs = SLOT_CEILING_MS }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const started = now();
+	let lastProgress = started;
+	for (;;) {
+		const got = tryAcquireBuildSlot({
+			max,
+			root,
+			logFile
+		});
+		if (got) return got;
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for one of ${max} build slots, and every slot is held by a process that is still running, or by a holder Stim cannot identify. Slots live under ` + buildSlotsDir() + "; remove a slot directory whose builder is not really building, or raise concurrency.maxBuilds.");
+			err.code = "STIM_BUILD_SLOT_TIMEOUT";
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(slotWaitingLine({
+				max,
+				elapsedMs: elapsed
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+function releaseBuildSlot(handle) {
+	if (!handle || handle.unlimited) return false;
+	stopDeclaringSpawnsOn(handle.claim);
+	return (0, ownership_claim_exports.releaseClaim)(handle.claim);
+}
+function listBuildSlots() {
+	const dir = buildSlotsDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const slots = [];
+	for (const name of names) {
+		if (!name.startsWith(SLOT_PREFIX)) continue;
+		const path = join$1(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		const index = Number(name.slice(5));
+		slots.push({
+			path,
+			name,
+			index: Number.isFinite(index) ? index : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return slots;
+}
+//#endregion
+//#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-BL2NFckr.mjs → ios-B2Fpqvlb.mjs}

@@ -1,8 +1,9 @@
-import { g as loadConfig } from "./config-Cp9lM3wX.mjs";
-import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+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 { I as IOS_SIMULATOR_APPS } from "./settings-D030k0t4.mjs";
-import { existsSync, mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+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
@@ -37,7 +38,7 @@ function parseIosSimulatorApp(value, source = "iosSimulatorApp in machine config
 	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", [
@@ -369,11 +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}"`, {
-			timeoutMs: SIMCTL_CREATE_TIMEOUT_MS,
-			killSignal: "SIGKILL"
-		}).trim(),
+		udid,
 		name,
 		deviceType: choice.deviceType,
 		runtime: choice.runtime
@@ -387,6 +390,13 @@ function renameIosSim(udid, name) {
 		name
 	], SIMCTL_OPTIONS);
 }
+function eraseIosSim(udid) {
+	getExecutor().runFile("xcrun", [
+		"simctl",
+		"erase",
+		udid
+	], SIMCTL_OPTIONS);
+}
 function resetIosPrivacy(udid) {
 	getExecutor().runFile("xcrun", [
 		"simctl",
@@ -449,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-").`);
+	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) {
@@ -514,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", [
@@ -542,4 +508,4 @@ function listIosRuntimes() {
 	}));
 }
 //#endregion
-export { readHostMemoryPressure as A, resolveOwnedIosSim as C, configuredIosSimulatorViewer as D, uninstallIosApp as E, parseIosSimulatorApp as O, resolveIosCreation as S, shutdownIosSim as T, parseRuntimeVersion as _, deleteIosSim as a, resetIosKeychain as b, iosRuntimeMatches as c, listAllIosSimsAsync as d, listIosDeviceTypes as f, parkedSimName as g, ownedSimName as h, createOwnedIosSim as i, hostMemoryPressureAdvice as k, iosSimulatorFailureAdvice as l, listUserApps as m, bootIosSim as n, deleteParkedIosSim as o, listIosRuntimes as p, clearAppDataContainer as r, findAppDataContainer as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSims as u, parseSimctlList as v, sanitizeDeviceLabel as w, resetIosPrivacy as x, renameIosSim 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 };