stim 1.14.0 → 1.16.0

package/dist/teardown-CL6vDs2Y.mjs

@@ -0,0 +1,727 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { D as withConfigLock, H as projectDeviceSlots, _ as loadConfig, k as acquireAvdClaim, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { gt as repoRoot } from "./settings-oTSkkNrM.mjs";
+import { u as signalProcessTree } from "./metro-BeK1ZPz1.mjs";
+import { g as workspaceAgentDeviceDir, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { _ as removeSingletonFiles, c as webClaimRoot, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, o as readWebRecord, t as CDP_PORT_LABEL } from "./state-C1jB7Q8q.mjs";
+import { t as agentDeviceDaemon, u as readAgentDeviceRecords } from "./activity-BxwdD81S.mjs";
+import { n as readCreatedDevices, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-D5owjN4C.mjs";
+import { B as ownedAvdSystemImage, I as ownedAvdDirectory, J as resolveOwnedAvdSerial, L as ownedAvdMatchesConfiguration, M as listOrphanedAvdDirectories, O as listAdbDevices, X as shutdownAndroidEmulator, Z as sleepSync, _ as avdStorageRoots, dt as parkSim, et as waitForAndroidEmulatorShutdown, f as assertOwnedAvdStopped, h as avdPathExists, it as isStimOwnedAvd, lt as eraseParkedAfter, mt as removeParkedAfter, nt as wipeAvdUserData, pt as readParked, x as deleteAvd } from "./android-B_NumVyQ.mjs";
+import { E as shutdownIosSim, _ as parseRuntimeVersion, a as deleteIosSim, b as renameIosSim, f as listIosDeviceTypes, g as parkedSimName, o as deleteParkedIosSim, s as eraseIosSim, w as resolveOwnedIosSim } from "./ios-BaInn3sW.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { r as releaseBrowserPort } from "./named-ports-Bk_YXEmE.mjs";
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, realpathSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+import { homedir } from "node:os";
+import { isDeepStrictEqual } from "node:util";
+//#region src/devices/agent-device-cleanup.ts
+function parseAgentDeviceSessions(output) {
+	const result = JSON.parse(output);
+	if (result?.success !== true || !Array.isArray(result.data?.sessions)) throw new Error("agent-device did not return a successful session list");
+	return result.data.sessions.flatMap((entry) => {
+		if (!entry || typeof entry !== "object") return [];
+		const row = entry;
+		const id = row.platform === "ios" ? row.device_udid : row.id;
+		if (row.platform !== "ios" && row.platform !== "android" || typeof row.name !== "string" || !row.name.trim() || typeof id !== "string" || !id || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || row.platform === "ios" && row.id !== void 0 && row.id !== id) return [];
+		return [{
+			name: typeof row.address === "string" && row.address.trim() ? row.address : row.name,
+			platform: row.platform,
+			id,
+			device: typeof row.device === "string" ? row.device : null,
+			createdAt: row.createdAt
+		}];
+	});
+}
+function isOwnDeviceSession(session, device, owner) {
+	if (session.platform !== device.platform || device.id !== null && session.id !== device.id) return false;
+	if (device.platform === "android" && session.device !== device.avdName.replaceAll("_", " ")) return false;
+	if (!owner) return true;
+	return owner.claims.some((claim) => claim.deviceId === session.id && claim.session === session.name && claim.workspace !== null && (within(owner.workspace, claim.workspace) || claim.workspace === owner.repoRoot));
+}
+function within(root, path) {
+	const rest = relative(root, path);
+	return rest === "" || !isAbsolute(rest) && rest.split(sep)[0] !== "..";
+}
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+function deviceClaims(device) {
+	return readAgentDeviceRecords(homedir()).filter((record) => record.kind === "claim" && (device.id === null || record.deviceId === device.id)).map((record) => ({
+		deviceId: record.deviceId,
+		session: record.session,
+		workspace: record.workspace && canonical(record.workspace)
+	}));
+}
+function report(message) {
+	process.stderr.write(`${phaseLine("device", message)}\n`);
+}
+function closeOwnedDeviceSessions(device, stillOwned, workspace, repoRoot) {
+	const exec = getExecutor();
+	try {
+		if (!exec.findExecutable("agent-device")) return;
+		const root = workspace === void 0 ? void 0 : canonical(workspace);
+		if (root === null) return;
+		const owner = root === void 0 ? void 0 : {
+			workspace: root,
+			repoRoot: repoRoot && (canonical(repoRoot) ?? void 0),
+			claims: deviceClaims(device)
+		};
+		const stateDir = root === void 0 ? void 0 : workspaceAgentDeviceDir(root);
+		const stateDirs = [void 0, ...stateDir && !["none", "dead"].includes(agentDeviceDaemon(stateDir)) ? [stateDir] : []];
+		for (const dir of stateDirs) {
+			const deadline = Date.now() + 15e3;
+			const run = (args) => {
+				const remaining = deadline - Date.now();
+				if (remaining <= 0) throw new Error("agent-device cleanup timed out");
+				return exec.runFile("agent-device", [
+					...args,
+					...dir ? ["--state-dir", dir] : [],
+					"--json",
+					"--daemon-transport",
+					"socket"
+				], {
+					timeoutMs: Math.min(5e3, remaining),
+					killSignal: "SIGKILL"
+				});
+			};
+			const list = () => parseAgentDeviceSessions(run([
+				"session",
+				"list",
+				"--session",
+				"stim-teardown-inventory"
+			]));
+			try {
+				const sessions = list().filter((session) => isOwnDeviceSession(session, device, owner));
+				for (const session of sessions) try {
+					if (!list().some((current) => current.name === session.name && current.platform === session.platform && current.id === session.id && current.createdAt === session.createdAt)) continue;
+					if (!stillOwned(session.id)) continue;
+					if (JSON.parse(run([
+						"close",
+						"--session",
+						session.name,
+						"--session-lock",
+						"reject",
+						"--platform",
+						device.platform,
+						device.platform === "ios" ? "--udid" : "--serial",
+						session.id
+					]))?.success !== true) throw new Error("agent-device did not confirm session close");
+					report(`closed agent-device session ${session.name} on ${session.id}`);
+				} catch (error) {
+					report(`could not close agent-device session ${session.name} on ${session.id}: ${error.message}`);
+				}
+			} catch (error) {
+				report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
+			}
+		}
+	} catch (error) {
+		report(`could not list agent-device sessions for ${device.platform === "ios" ? device.id : device.id ?? device.avdName}: ${error.message}`);
+	}
+}
+//#endregion
+//#region src/devices/teardown.ts
+function teardownParkedAvd(avdName) {
+	try {
+		return removeParkedAfter("android", avdName, () => {
+			const result = teardownOwnedAvd(avdName, {
+				del: true,
+				owner: { pool: true }
+			});
+			if (result.status !== "torn-down" && result.status !== "missing") throw new Error(result.reason);
+		}) ? {
+			status: "torn-down",
+			label: avdName
+		} : {
+			status: "skipped",
+			kind: "not-parked",
+			reason: "emulator is no longer parked"
+		};
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSim } = {}) {
+	try {
+		const removed = removeParkedAfter("ios", udid, () => {
+			closeOwnedDeviceSessions({
+				platform: "ios",
+				id: udid
+			}, () => Boolean(resolveOwnedIosSim(udid).sim));
+			deleteSim(udid);
+		});
+		if (!removed) return {
+			status: "skipped",
+			kind: "not-parked",
+			reason: "simulator is no longer parked"
+		};
+		return {
+			status: "torn-down",
+			label: label ?? removed.name
+		};
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+function eraseParkedIosSim(udid, { label } = {}) {
+	try {
+		const erased = eraseParkedAfter("ios", udid, (_record, eraseStarted) => {
+			closeOwnedDeviceSessions({
+				platform: "ios",
+				id: udid
+			}, () => Boolean(resolveOwnedIosSim(udid).sim));
+			const resolved = resolveOwnedIosSim(udid);
+			if (resolved.missing) throw new Error(`simulator ${udid} is not on this machine`);
+			if (resolved.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(resolved.notOwned)}`);
+			const state = resolved.sim.state;
+			if (state !== "Shutdown") throw new Error(`simulator ${udid} is ${state}, not Shutdown; it was kept`);
+			eraseStarted();
+			eraseIosSim(udid);
+		});
+		if (!erased) return {
+			status: "skipped",
+			kind: "not-parked",
+			reason: "simulator is no longer parked"
+		};
+		return {
+			status: "torn-down",
+			label: label ?? erased.name
+		};
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+function eraseParkedAvd(avdName) {
+	try {
+		return eraseParkedAfter("android", avdName, (_record, eraseStarted) => {
+			if (resolveOwnedAvdSerial(avdName).serial) throw new Error(`AVD ${avdName} is running; it was kept`);
+			const result = teardownOwnedAvd(avdName, {
+				wipe: true,
+				owner: { pool: true },
+				onWipeStart: eraseStarted
+			});
+			if (result.status !== "torn-down") throw new Error(result.reason ?? `AVD ${avdName} is ${result.status}`);
+		}) ? {
+			status: "torn-down",
+			label: avdName
+		} : {
+			status: "skipped",
+			kind: "not-parked",
+			reason: "emulator is no longer parked"
+		};
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+const IOS_SHUTDOWN_SETTLE_MS = 15e3;
+const ADB_RELEASE_WAIT_MS = 3e3;
+function repoRootAbove(workspace) {
+	if (workspace === void 0 || !getExecutor().findExecutable("agent-device")) return void 0;
+	const root = repoRoot(workspace);
+	try {
+		return root && realpathSync(root) !== realpathSync(workspace) ? root : void 0;
+	} catch {
+		return;
+	}
+}
+const IOS_SHUTDOWN_POLL_MS = 250;
+const IOS_SHUTDOWN_ATTEMPTS = 2;
+function settleIosSimShutdown(udid, { now = Date.now, sleep = sleepSync }) {
+	let resolved = resolveOwnedIosSim(udid);
+	for (let attempt = 1;; attempt++) {
+		const deadline = now() + IOS_SHUTDOWN_SETTLE_MS;
+		while (resolved.sim && resolved.sim.state !== "Shutdown" && now() < deadline) {
+			sleep(IOS_SHUTDOWN_POLL_MS);
+			resolved = resolveOwnedIosSim(udid);
+		}
+		if (!resolved.sim || resolved.sim.state === "Shutdown" || attempt === IOS_SHUTDOWN_ATTEMPTS) return resolved;
+		shutdownIosSim(udid);
+		resolved = resolveOwnedIosSim(udid);
+	}
+}
+function iosShutdownFailureReason(udid, state) {
+	return `simulator ${udid} is still ${state} after ${IOS_SHUTDOWN_ATTEMPTS} shutdown attempts and ${IOS_SHUTDOWN_ATTEMPTS * IOS_SHUTDOWN_SETTLE_MS / 1e3}s of waiting`;
+}
+function parkOwnedIosSim(settled, udid, park) {
+	if (settled.missing) throw new Error(`simulator ${udid} disappeared after shutdown`);
+	if (settled.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(settled.notOwned)}`);
+	const sim = settled.sim;
+	if (sim.state !== "Shutdown") throw new Error(iosShutdownFailureReason(udid, sim.state));
+	const model = listIosDeviceTypes().find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null;
+	const runtime = parseRuntimeVersion(sim.runtime);
+	const name = parkedSimName(sim.udid, {
+		model,
+		runtime
+	});
+	renameIosSim(sim.udid, name);
+	const record = {
+		udid: sim.udid,
+		name,
+		deviceTypeIdentifier: sim.deviceTypeIdentifier,
+		runtimeIdentifier: sim.runtime,
+		parkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		simslimManaged: Boolean(park.simslimManaged),
+		...park.appId ? { bundleId: park.appId } : {},
+		...park.cacheKey ? { cacheKey: park.cacheKey } : {}
+	};
+	return {
+		record,
+		evicted: parkSim({
+			platform: "ios",
+			projectPath: park.projectPath,
+			slot: park.slot,
+			record,
+			max: park.max
+		})
+	};
+}
+function teardownOwnedIosSim(udid, { del = false, label, park, workspace, shutdownClock = {} } = {}) {
+	let parkFallback;
+	try {
+		const resolved = resolveOwnedIosSim(udid);
+		if (resolved.notOwned) return {
+			status: "skipped",
+			kind: "not-owned",
+			reason: `sim "${resolved.notOwned}" is not Stim-owned: Stim has no record of creating it`
+		};
+		if (resolved.missing) return { status: "missing" };
+		closeOwnedDeviceSessions({
+			platform: "ios",
+			id: udid
+		}, () => Boolean(resolveOwnedIosSim(udid).sim), workspace);
+		const current = resolveOwnedIosSim(udid);
+		if (current.missing) return { status: "missing" };
+		if (current.notOwned) return {
+			status: "skipped",
+			kind: "not-owned",
+			reason: "simulator ownership changed before shutdown"
+		};
+		shutdownIosSim(udid);
+		const sim = resolved.sim;
+		if (del && park && park.max > 0) try {
+			const { record, evicted } = parkOwnedIosSim(settleIosSimShutdown(udid, shutdownClock), udid, park);
+			const removed = [];
+			const failures = [];
+			for (const entry of evicted) {
+				const result = teardownParkedIosSim(entry.udid, { label: entry.name });
+				if (result.status === "torn-down") removed.push({
+					udid: entry.udid,
+					name: entry.name
+				});
+				else if (result.status === "failed") failures.push(`could not delete evicted ${entry.name} (${entry.udid}): ${result.reason}`);
+			}
+			return {
+				status: "torn-down",
+				label: label ?? sim.name ?? udid,
+				parked: {
+					udid: record.udid,
+					name: record.name
+				},
+				evicted: removed,
+				...failures.length ? { evictionFailures: failures } : {}
+			};
+		} catch (e) {
+			parkFallback = String(e?.message || e);
+		}
+		if (del) {
+			deleteIosSim(udid);
+			return {
+				status: "torn-down",
+				label: label ?? sim.name ?? udid,
+				...parkFallback ? { parkFallback } : {}
+			};
+		}
+		const settled = settleIosSimShutdown(udid, shutdownClock);
+		if (settled.sim && settled.sim.state !== "Shutdown") return {
+			status: "failed",
+			label: label ?? sim.name ?? udid,
+			reason: iosShutdownFailureReason(udid, settled.sim.state)
+		};
+		const root = sim.state === "Shutdown" ? void 0 : repoRootAbove(workspace);
+		if (root && settled.sim) closeOwnedDeviceSessions({
+			platform: "ios",
+			id: udid
+		}, () => resolveOwnedIosSim(udid).sim?.state === "Shutdown", workspace, root);
+		return {
+			status: "torn-down",
+			label: label ?? sim.name ?? udid
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			reason: String(e?.message || e),
+			...parkFallback ? { parkFallback } : {}
+		};
+	}
+}
+function assertAvdReferences(avdName, owner) {
+	const config = loadConfig();
+	if (!config) throw new Error("Cannot verify AVD references without a Stim config; the data was kept.");
+	if (owner && "projectPath" in owner && owner.expectedRecord && !isDeepStrictEqual(deviceSlotPlatforms(config.projects[owner.projectPath], owner.slot)?.android, owner.expectedRecord)) throw new Error(`AVD ${avdName} has a changed workspace record; its data was kept.`);
+	for (const [projectPath, project] of Object.entries(config.projects)) for (const { slot, platforms } of projectDeviceSlots(project)) {
+		if (platforms.android?.avdName?.toLowerCase() !== avdName.toLowerCase()) continue;
+		if (!owner || !("projectPath" in owner) || owner.projectPath !== projectPath || (owner.slot ?? "default") !== slot || !platforms.android.owned) throw new Error(`AVD ${avdName} is referenced by ${projectPath} (${slot}); its data was kept.`);
+	}
+	if (readParked("android", { config }).some((entry) => entry.name.toLowerCase() === avdName.toLowerCase()) && !(owner && "pool" in owner)) throw new Error(`AVD ${avdName} is in the emulator pool; its data was kept.`);
+}
+function removeOrphanedAvdDirectory(candidate, owner) {
+	const surveyed = listOrphanedAvdDirectories(candidate.name).find((entry) => entry.directory === candidate.directory);
+	if (!surveyed || surveyed.name !== candidate.name || surveyed.dev !== candidate.dev || surveyed.ino !== candidate.ino) throw new Error(`AVD data at ${candidate.directory} changed or is registered; it was kept.`);
+	assertOwnedAvdStopped(candidate.name, { resolveDirectory: () => candidate.directory });
+	const detached = withConfigLock(() => {
+		const current = lstatSync(candidate.directory);
+		if (!current.isDirectory() || current.dev !== candidate.dev || current.ino !== candidate.ino) throw new Error(`AVD data at ${candidate.directory} changed or is registered; it was kept.`);
+		assertAvdReferences(candidate.name, owner);
+		const name = `stim-gc-${randomUUID()}`;
+		recordCreatedDevice("android", name);
+		const destination = join(dirname(candidate.directory), `${name}.avd`);
+		try {
+			renameSync(candidate.directory, destination);
+		} catch (error) {
+			forgetCreatedDevice("android", name);
+			throw error;
+		}
+		forgetCreatedDevice("android", candidate.name);
+		return destination;
+	});
+	const current = lstatSync(detached);
+	if (!current.isDirectory() || current.dev !== candidate.dev || current.ino !== candidate.ino) throw new Error(`Detached AVD data changed at ${detached}; it was kept.`);
+	try {
+		rmSync(detached, { recursive: true });
+	} catch (error) {
+		throw new Error(`Could not remove AVD data at ${detached}; retry gc --delete: ${error.message}`, { cause: error });
+	}
+	forgetCreatedDevice("android", basename(detached, ".avd"));
+}
+function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
+	const candidates = surveyed ? [surveyed] : listOrphanedAvdDirectories(avdName);
+	if (candidates.length === 0) {
+		if (avdStorageRoots().some((root) => avdPathExists(join(root, `${avdName}.ini`)) || avdPathExists(join(root, `${avdName}.avd`)))) throw new Error(`AVD ${avdName} is not listed but its storage remains; it was kept.`);
+		return { status: "missing" };
+	}
+	if (!del) return {
+		status: "skipped",
+		reason: "AVD registration is missing; its data was kept."
+	};
+	for (const candidate of candidates) {
+		if (candidate.name !== avdName) throw new Error(`AVD data does not match ${avdName}; it was kept.`);
+		removeOrphanedAvdDirectory(candidate, owner);
+	}
+	return {
+		status: "torn-down",
+		label: avdName
+	};
+}
+function teardownOwnedAvd(avdName, options = {}) {
+	let claim;
+	try {
+		if (!isStimOwnedAvd(avdName)) return {
+			status: "skipped",
+			kind: "not-owned",
+			reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
+		};
+		claim = acquireAvdClaim(avdName);
+		const result = teardownClaimedAvd(avdName, claim, options);
+		if (result.status === "torn-down" || result.status === "missing") options.onRemoved?.();
+		return result;
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
+	}
+}
+function serialFree(serial) {
+	const adb = listAdbDevices();
+	return ![
+		...adb.emulators,
+		...adb.physical,
+		...adb.unhealthy
+	].some((entry) => entry.serial === serial);
+}
+function teardownClaimedAvd(avdName, claim, { del = false, wipe = false, park, owner, workspace, orphanedDirectory, onlyIfMissing = false, onWipeStart, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = assertOwnedAvdStopped, resolveAvd = resolveOwnedAvdSerial }) {
+	let parkFallback;
+	try {
+		if (del || wipe) withConfigLock(() => assertAvdReferences(avdName, owner));
+		const resolved = resolveAvd(avdName);
+		if (resolved.notOwned) return {
+			status: "skipped",
+			kind: "not-owned",
+			reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
+		};
+		if (resolved.missing) {
+			if (wipe) throw new Error(`AVD ${avdName} is not registered; its data was kept.`);
+			return teardownUnregisteredAvd(avdName, del, owner, orphanedDirectory);
+		}
+		if (onlyIfMissing) return {
+			status: "skipped",
+			reason: "AVD registration appeared; its record was kept."
+		};
+		if (orphanedDirectory) return {
+			status: "skipped",
+			reason: "AVD registration appeared; its data was kept."
+		};
+		const serial = resolved.serial;
+		const stillStopped = (sessionSerial) => {
+			const current = resolveAvd(avdName);
+			return !current.notOwned && !current.missing && !current.serial && serialFree(sessionSerial);
+		};
+		if (serial) {
+			const stillOwned = () => {
+				const current = resolveAvd(avdName);
+				return !current.notOwned && !current.missing && current.serial === serial;
+			};
+			closeOwnedDeviceSessions({
+				platform: "android",
+				id: serial,
+				avdName
+			}, stillOwned, workspace);
+			if (!stillOwned()) throw new Error(`Owned AVD ${avdName} changed before shutdown; it was kept.`);
+			waitForShutdown(avdName, (timeoutMs) => {
+				(0, ownership_claim_exports.markClaimChildPending)(claim);
+				try {
+					shutdownAndroidEmulator(serial, timeoutMs);
+				} finally {
+					(0, ownership_claim_exports.clearClaimChild)(claim);
+				}
+			});
+			const root = repoRootAbove(workspace);
+			if (root) {
+				const deadline = Date.now() + ADB_RELEASE_WAIT_MS;
+				while (!serialFree(serial) && Date.now() < deadline) sleepSync(250);
+				closeOwnedDeviceSessions({
+					platform: "android",
+					id: serial,
+					avdName
+				}, stillStopped, workspace, root);
+			}
+		} else {
+			closeOwnedDeviceSessions({
+				platform: "android",
+				id: null,
+				avdName
+			}, stillStopped, workspace);
+			waitForShutdown(avdName, null);
+		}
+		if (wipe && !del) {
+			const current = resolveAvd(avdName);
+			if (current.notOwned || current.missing) throw new Error(`AVD ${avdName} changed before its data was wiped.`);
+			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before its data was wiped.`);
+			assertStopped(avdName);
+			withConfigLock(() => assertAvdReferences(avdName, owner));
+			const directory = ownedAvdDirectory(avdName);
+			if (!directory) throw new Error(`The data directory of AVD ${avdName} could not be resolved.`);
+			onWipeStart?.();
+			wipeAvdUserData(directory);
+		}
+		if (del) {
+			const current = resolveAvd(avdName);
+			if (current.notOwned) return {
+				status: "skipped",
+				kind: "not-owned",
+				reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
+			};
+			if (current.missing) return teardownUnregisteredAvd(avdName, del, owner);
+			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before deletion.`);
+			assertStopped(avdName);
+			withConfigLock(() => assertAvdReferences(avdName, owner));
+			if (park && park.max > 0) try {
+				const systemImage = ownedAvdSystemImage(avdName);
+				if (!systemImage || !park.configuration || !ownedAvdMatchesConfiguration(avdName, park.configuration)) throw new Error("the AVD has no verified creation configuration");
+				const evicted = parkSim({
+					platform: "android",
+					projectPath: park.projectPath,
+					slot: park.slot,
+					max: park.max,
+					record: {
+						udid: avdName,
+						name: avdName,
+						systemImage,
+						configuration: park.configuration,
+						parkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+						...park.appId ? { packageName: park.appId } : {},
+						...park.cacheKey ? { cacheKey: park.cacheKey } : {}
+					}
+				});
+				const removed = [];
+				const failures = [];
+				for (const entry of evicted) {
+					const result = teardownParkedAvd(entry.name);
+					if (result.status === "torn-down") removed.push({
+						udid: entry.name,
+						name: entry.name,
+						platform: "android"
+					});
+					else if (result.status === "failed") failures.push(`could not delete evicted ${entry.name}: ${result.reason}`);
+				}
+				return {
+					status: "torn-down",
+					label: avdName,
+					parked: {
+						udid: avdName,
+						name: avdName,
+						platform: "android"
+					},
+					evicted: removed,
+					...failures.length ? { evictionFailures: failures } : {}
+				};
+			} catch (error) {
+				parkFallback = String(error?.message || error);
+			}
+			const directory = ownedAvdDirectory(avdName);
+			const paths = avdStorageRoots().map((root) => join(root, `${avdName}.ini`));
+			if (directory) paths.push(directory);
+			(0, ownership_claim_exports.markClaimChildPending)(claim);
+			try {
+				deleteAvd(avdName);
+			} finally {
+				(0, ownership_claim_exports.clearClaimChild)(claim);
+			}
+			const remaining = paths.filter(avdPathExists);
+			if (remaining.length) throw new Error(`AVD ${avdName} was only partially deleted; data remains at ${remaining.join(", ")}.`);
+		}
+		return {
+			status: "torn-down",
+			label: avdName,
+			serial: resolved.serial ?? null,
+			...parkFallback ? { parkFallback } : {}
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			reason: String(e?.message || e)
+		};
+	}
+}
+const BROWSER_EXIT_WAIT_MS = 15e3;
+const CHROME_KILL_WAIT_MS = 5e3;
+async function stopOwnedChrome(record) {
+	for (const signal of ["SIGTERM", "SIGKILL"]) {
+		const state = chromeProcessState(record);
+		if (state === "gone") return true;
+		if (state === "unknown") return false;
+		try {
+			signalProcessTree(record.pid, signal, { group: true });
+		} catch {}
+		const deadline = Date.now() + CHROME_KILL_WAIT_MS;
+		while (chromeProcessState(record) !== "gone" && Date.now() < deadline) await sleepAsync(50);
+	}
+	return chromeProcessState(record) === "gone";
+}
+const sleepAsync = (ms) => new Promise((done) => setTimeout(done, ms));
+/**
+* Closes the workspace's Stim-owned Chrome and its supervisor, after verifying both process identities. With
+* `deleteProfile`, it also deletes the profile directory, only when the created-devices ledger lists it.
+*/
+async function teardownOwnedBrowser(root, options = {}) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), "web", () => teardownBrowserHeld(root, options), {
+			external: true,
+			ownerPurpose: "browser teardown"
+		});
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+/** {@link teardownOwnedBrowser} for a caller that already holds the {@link BROWSER_LOCK} lock. */
+async function teardownBrowserHeld(root, { deleteProfile = false } = {}) {
+	try {
+		const record = readWebRecord(root);
+		const profile = record?.profile ?? webProfileDir(root);
+		if (record) {
+			const supervisor = (0, process_identity_exports.inspectProcessIdentity)(record);
+			const chrome = record.chromeProcess ? (0, process_identity_exports.inspectProcessIdentity)(record.chromeProcess) : "gone";
+			if (supervisor === "unknown" || chrome === "unknown") return {
+				status: "skipped",
+				kind: "not-verified",
+				reason: `the browser supervisor (pid ${record.pid}) or its Chrome could not be verified; its record was kept`
+			};
+			if (supervisor === "same") {
+				try {
+					process.kill(record.pid, "SIGTERM");
+				} catch {}
+				if (!await (0, process_identity_exports.waitForProcessExit)(record, BROWSER_EXIT_WAIT_MS)) return {
+					status: "failed",
+					reason: `browser supervisor pid ${record.pid} did not exit`
+				};
+			}
+			if (record.chromeProcess && !await stopOwnedChrome(record.chromeProcess)) return {
+				status: "failed",
+				reason: `Chrome pid ${record.chromeProcess.pid} did not exit`
+			};
+			const holder = liveProfileHolder(profile);
+			if (holder !== null) return {
+				status: "skipped",
+				kind: "not-verified",
+				reason: `pid ${holder} still holds ${profile}, and the browser record does not name it; it was left running`
+			};
+			const claims = (0, ownership_claim_exports.clearFreeClaimSet)({
+				root: webClaimRoot(root),
+				label: "browser supervisor"
+			});
+			if (claims.status !== "cleared") return {
+				status: "skipped",
+				kind: "not-verified",
+				reason: claims.status === "held" ? `the browser supervisor claim is still held${claims.holder ? ` by pid ${claims.holder.owner.pid}` : ""}` : `the browser supervisor claim could not be cleared (${claims.reason}); remove it with ${(0, ownership_claim_exports.claimRemoveCommand)(webClaimRoot(root))}`
+			};
+			clearWebRecord(root, record);
+			await releaseBrowserPort(root, record.cdpPort);
+		} else {
+			const holder = liveProfileHolder(profile);
+			if (holder !== null) return {
+				status: "skipped",
+				kind: "not-verified",
+				reason: `pid ${holder} holds ${profile} but no browser supervisor is recorded; it was left running`
+			};
+			const port = getProject(root)?.ports?.[CDP_PORT_LABEL];
+			if (typeof port === "number") await releaseBrowserPort(root, port);
+		}
+		if (existsSync(profile)) removeSingletonFiles(profile);
+		if (deleteProfile && existsSync(profile)) {
+			if (!readCreatedDevices().web.has(profile)) return {
+				status: "skipped",
+				kind: "not-owned",
+				reason: `${profile} is not in Stim's ledger; it was kept`
+			};
+			rmSync(profile, {
+				recursive: true,
+				force: true
+			});
+			forgetCreatedDevice("web", profile);
+		}
+		return record ? {
+			status: "torn-down",
+			label: `Chrome (${profile})`
+		} : { status: "missing" };
+	} catch (error) {
+		return {
+			status: "failed",
+			reason: String(error?.message || error)
+		};
+	}
+}
+//#endregion
+export { teardownOwnedBrowser as a, teardownParkedIosSim as c, teardownOwnedAvd as i, eraseParkedIosSim as n, teardownOwnedIosSim as o, teardownBrowserHeld as r, teardownParkedAvd as s, eraseParkedAvd as t };