stim 1.3.0 → 1.4.0

package/dist/{teardown-ClFp1Aax.mjs → teardown-KsPpvldq.mjs}

@@ -1,18 +1,19 @@
 import { t as getExecutor } from "./exec-CyylIdq9.mjs";
-import { B as removeSlotDevice, C as withConfigLock, F as assignSlotDevice, L as deviceSlotPlatforms, g as loadConfig, s as ensureConfig, y as saveConfig, z as projectDeviceSlots } from "./config-CcefMY2Q.mjs";
+import { C as withConfigLock, E as ownership_claim_exports, F as deviceSlotPlatforms, L as projectDeviceSlots, N as assignSlotDevice, R as removeSlotDevice, T as acquireAvdClaim, d as getConfigPath, g as loadConfig, s as ensureConfig, u as getConfigDir, y as saveConfig } from "./config-6vdGngKa.mjs";
 import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { D as workspaceLogsDir } from "./state-B3XA2wp2.mjs";
-import { l as resolvePackageJson } from "./project-fKmuIaMI.mjs";
+import { _ as workspaceLogsDir } from "./workspace-state-Do1e2mOH.mjs";
+import { l as resolvePackageJson } from "./project-CBFCwnN5.mjs";
 import { n as stripAnsi } from "./process-output-C7IlIzd7.mjs";
-import { E as ownedAvdMatchesConfiguration, F as shutdownAndroidEmulator, I as waitForAndroidEmulatorShutdown, N as resolveOwnedAvdSerial, O as ownedAvdSystemImage, S as listOrphanedAvdDirectories, T as ownedAvdDirectory, l as avdStorageRoots, o as assertOwnedAvdStopped, p as deleteAvd, s as avdPathExists } from "./android-BqVIJoG7.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-DizT4OMk.mjs";
+import { l as phaseLine } from "./command-output-BuIb_ZOI.mjs";
+import { E as ownedAvdMatchesConfiguration, F as shutdownAndroidEmulator, I as waitForAndroidEmulatorShutdown, N as resolveOwnedAvdSerial, O as ownedAvdSystemImage, S as listOrphanedAvdDirectories, T as ownedAvdDirectory, l as avdStorageRoots, o as assertOwnedAvdStopped, p as deleteAvd, s as avdPathExists } from "./android-BkM4qTaN.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-D4P7iTvf.mjs";
 import { C as shutdownIosSim, _ as renameIosSim, a as deleteIosSim, d as listIosDeviceTypes, g as parseRuntimeVersion, h as parkedSimName, o as deleteParkedIosSim, r as clearAppDataContainer, s as findAppDataContainer, x as resolveOwnedIosSim } from "./ios-Deh5js5V.mjs";
 import { createRequire } from "node:module";
 import { existsSync, lstatSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { format } from "node:util";
+import { format, isDeepStrictEqual } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/engine/remote-cache.ts
 const EAS_PROVIDER_PACKAGE = "eas-build-cache-provider";
@@ -592,8 +593,14 @@ function writeParked(config, platform, records) {
 function oldestFirst(records) {
 	return records.toSorted((a, b) => String(a.parkedAt).localeCompare(String(b.parkedAt)));
 }
+function isLegacyDeletionClaim(value) {
+	if (value === void 0) return false;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return true;
+	const marker = value;
+	return marker.kind !== "ownership-claim" || typeof marker.claimId !== "string" || marker.claimId.length === 0;
+}
 function selectParked(records, { deviceTypeIdentifier, runtimeIdentifier }) {
-	return oldestFirst(records.filter((r) => r.deletionClaim === void 0 && r.deviceTypeIdentifier === deviceTypeIdentifier && r.runtimeIdentifier === runtimeIdentifier));
+	return oldestFirst(records.filter((r) => !isLegacyDeletionClaim(r.deletionClaim) && r.deviceTypeIdentifier === deviceTypeIdentifier && r.runtimeIdentifier === runtimeIdentifier));
 }
 function evictOverflow(records, max) {
 	if (records.length <= max) return {
@@ -623,103 +630,167 @@ function parkSim({ platform, projectPath, slot = "default", record, max }) {
 	});
 }
 function adoptParked({ platform, projectPath, slot = "default", udid, device }) {
-	return withConfigLock(() => {
-		const cfg = ensureConfig();
-		const records = readParked(platform, { config: cfg });
-		const taken = records.find((r) => r.udid === udid);
-		if (!taken || taken.deletionClaim !== void 0) return null;
-		if (deviceSlotPlatforms(cfg.projects[projectPath], slot)?.[platform]) return null;
-		writeParked(cfg, platform, records.filter((r) => r.udid !== udid));
-		const project = cfg.projects[projectPath];
-		if (!project) throw new Error(`Project not registered: ${projectPath}`);
-		assignSlotDevice(project, platform, device, slot);
-		saveConfig(cfg);
-		return taken;
-	});
-}
-function isProcessAlive(pid) {
+	const claim = claimParkedOperation(platform, udid);
+	if (!claim) return null;
 	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
+		return withConfigLock(() => {
+			const cfg = ensureConfig();
+			const records = readParked(platform, { config: cfg });
+			const taken = records.find((r) => r.udid === udid);
+			if (!taken || isLegacyDeletionClaim(taken.deletionClaim)) return null;
+			if (deviceSlotPlatforms(cfg.projects[projectPath], slot)?.[platform]) return null;
+			writeParked(cfg, platform, records.filter((r) => r.udid !== udid));
+			const project = cfg.projects[projectPath];
+			if (!project) throw new Error(`Project not registered: ${projectPath}`);
+			assignSlotDevice(project, platform, device, slot);
+			saveConfig(cfg);
+			const adopted = { ...taken };
+			delete adopted.deletionClaim;
+			return adopted;
+		});
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
 	}
 }
-function parseDeletionClaim(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-	const claim = value;
-	if (!Number.isSafeInteger(claim.pid) || claim.pid <= 0) return null;
-	if (typeof claim.token !== "string" || claim.token.length === 0) return null;
-	return {
-		pid: claim.pid,
-		token: claim.token
-	};
-}
-function claimParkedRemoval(platform, udid) {
-	return withConfigLock(() => {
-		const cfg = loadConfig();
-		if (!cfg) return null;
-		const records = readParked(platform, { config: cfg });
-		const record = records.find((candidate) => candidate.udid === udid);
-		if (!record) return null;
-		const existingClaim = parseDeletionClaim(record.deletionClaim);
-		if (record.deletionClaim !== void 0 && (!existingClaim || isProcessAlive(existingClaim.pid))) return null;
-		const token = randomUUID();
-		const claimedRecord = {
-			...record,
-			deletionClaim: {
-				pid: process.pid,
-				token
-			}
-		};
-		writeParked(cfg, platform, records.map((candidate) => candidate.udid === udid ? claimedRecord : candidate));
-		saveConfig(cfg);
-		const claimed = { ...record };
-		delete claimed.deletionClaim;
-		return {
-			record: claimed,
-			token
-		};
-	});
-}
-function clearParkedRemovalClaim(platform, udid, token) {
-	withConfigLock(() => {
-		const cfg = loadConfig();
-		if (!cfg) return;
-		const records = readParked(platform, { config: cfg });
-		const record = records.find((candidate) => candidate.udid === udid);
-		if (!record || parseDeletionClaim(record.deletionClaim)?.token !== token) return;
-		const restored = { ...record };
-		delete restored.deletionClaim;
-		writeParked(cfg, platform, records.map((candidate) => candidate.udid === udid ? restored : candidate));
-		saveConfig(cfg);
+function claimParkedOperation(platform, udid) {
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: join(getConfigDir(), "pool-locks", platform, `${encodeURIComponent(udid.toLowerCase())}.lock`),
+		mode: "exclusive",
+		label: `parked ${platform} device ${udid}`
 	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	return attempt.acquired ?? null;
 }
 function removeParkedAfter(platform, udid, beforeRemove) {
-	const claim = claimParkedRemoval(platform, udid);
+	const claim = claimParkedOperation(platform, udid);
 	if (!claim) return null;
 	try {
-		beforeRemove(claim.record);
-	} catch (error) {
+		const claimed = withConfigLock(() => {
+			const cfg = loadConfig();
+			if (!cfg) return null;
+			const records = readParked(platform, { config: cfg });
+			const current = records.find((candidate) => candidate.udid === udid);
+			if (!current) return null;
+			if (isLegacyDeletionClaim(current.deletionClaim)) throw new Error(`Parked ${platform} device ${udid} has a legacy deletionClaim in ${getConfigPath()}. Its PID does not establish whether the original operation finished. Keep the device and pool record; after verifying that neither the old Stim process nor its native child is using it, remove only that record's deletionClaim field and retry.`);
+			const record = { ...current };
+			delete record.deletionClaim;
+			const marked = {
+				...record,
+				deletionClaim: {
+					kind: "ownership-claim",
+					claimId: claim.claimId
+				}
+			};
+			writeParked(cfg, platform, records.map((candidate) => candidate.udid === udid ? marked : candidate));
+			saveConfig(cfg);
+			return {
+				record,
+				marked
+			};
+		});
+		if (!claimed) return null;
+		let completed = false;
+		let removed = null;
 		try {
-			clearParkedRemovalClaim(platform, udid, claim.token);
-		} catch {}
-		throw error;
+			(0, ownership_claim_exports.markClaimChildPending)(claim);
+			try {
+				beforeRemove(claimed.record);
+			} finally {
+				(0, ownership_claim_exports.clearClaimChild)(claim);
+			}
+			completed = true;
+		} finally {
+			withConfigLock(() => {
+				const cfg = loadConfig();
+				if (!cfg) return;
+				const records = readParked(platform, { config: cfg });
+				const current = records.find((candidate) => candidate.udid === udid);
+				if (!isDeepStrictEqual(current, claimed.marked)) return;
+				writeParked(cfg, platform, completed ? records.filter((candidate) => candidate.udid !== udid) : records.map((candidate) => candidate.udid === udid ? claimed.record : candidate));
+				saveConfig(cfg);
+				if (completed) removed = claimed.record;
+			});
+		}
+		return removed;
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
 	}
-	return withConfigLock(() => {
-		const cfg = loadConfig();
-		if (!cfg) return null;
-		const records = readParked(platform, { config: cfg });
-		if (parseDeletionClaim(records.find((candidate) => candidate.udid === udid)?.deletionClaim)?.token !== claim.token) return null;
-		writeParked(cfg, platform, records.filter((candidate) => candidate.udid !== udid));
-		saveConfig(cfg);
-		return claim.record;
-	});
 }
 function dropParked(platform, udid) {
 	return removeParkedAfter(platform, udid, () => {}) !== null;
 }
 //#endregion
+//#region src/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: row.name,
+			platform: row.platform,
+			id,
+			createdAt: row.createdAt
+		}];
+	});
+}
+function report(message) {
+	process.stderr.write(`${phaseLine("device", message)}\n`);
+}
+function closeOwnedDeviceSessions(device, stillOwned) {
+	const exec = getExecutor();
+	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,
+			"--json",
+			"--daemon-transport",
+			"socket"
+		], {
+			timeoutMs: Math.min(5e3, remaining),
+			killSignal: "SIGKILL"
+		});
+	};
+	const list = () => parseAgentDeviceSessions(run([
+		"session",
+		"list",
+		"--session",
+		"stim-teardown-inventory"
+	]));
+	try {
+		if (!exec.runQuiet("command -v agent-device", {
+			timeoutMs: 2e3,
+			killSignal: "SIGKILL"
+		})) return;
+		const sessions = list().filter((session) => session.platform === device.platform && session.id === device.id);
+		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()) return;
+			if (JSON.parse(run([
+				"close",
+				"--session",
+				session.name,
+				"--session-lock",
+				"reject",
+				"--platform",
+				device.platform,
+				device.platform === "ios" ? "--udid" : "--serial",
+				device.id
+			]))?.success !== true) throw new Error("agent-device did not confirm session close");
+			report(`closed agent-device session ${session.name} on ${device.id}`);
+		} catch (error) {
+			report(`could not close agent-device session ${session.name} on ${device.id}: ${error.message}`);
+		}
+	} catch (error) {
+		report(`could not list agent-device sessions for ${device.id}: ${error.message}`);
+	}
+}
+//#endregion
 //#region src/teardown.ts
 function teardownParkedAvd(avdName) {
 	try {
@@ -746,7 +817,13 @@ function teardownParkedAvd(avdName) {
 }
 function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSim } = {}) {
 	try {
-		const removed = removeParkedAfter("ios", udid, () => deleteSim(udid));
+		const removed = removeParkedAfter("ios", udid, () => {
+			closeOwnedDeviceSessions({
+				platform: "ios",
+				id: udid
+			}, () => Boolean(resolveOwnedIosSim(udid).sim));
+			deleteSim(udid);
+		});
 		if (!removed) return {
 			status: "skipped",
 			kind: "not-parked",
@@ -812,6 +889,17 @@ function teardownOwnedIosSim(udid, { del = false, label, park } = {}) {
 			reason: `sim is now named "${resolved.notOwned}", not Stim-owned by name`
 		};
 		if (resolved.missing) return { status: "missing" };
+		closeOwnedDeviceSessions({
+			platform: "ios",
+			id: udid
+		}, () => Boolean(resolveOwnedIosSim(udid).sim));
+		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 {
@@ -853,18 +941,24 @@ function teardownOwnedIosSim(udid, { del = false, label, park } = {}) {
 		};
 	}
 }
+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 = listOrphanedAvdDirectories(candidate.name).find((entry) => entry.directory === candidate.directory);
-		if (!current || current.name !== candidate.name || current.dev !== candidate.dev || current.ino !== candidate.ino) throw new Error(`AVD data at ${candidate.directory} changed or is registered; it was kept.`);
-		const config = loadConfig();
-		if (!config) throw new Error("Cannot verify AVD references without a Stim config; the data was kept.");
-		for (const [projectPath, project] of Object.entries(config.projects)) for (const { platforms } of projectDeviceSlots(project)) {
-			if (platforms.android?.avdName !== candidate.name) continue;
-			if (!owner || !("projectPath" in owner) || owner.projectPath !== projectPath || !platforms.android.owned) throw new Error(`AVD ${candidate.name} is referenced by ${projectPath}; its data was kept.`);
-		}
-		if (readParked("android", { config }).some((entry) => entry.name === candidate.name) && !(owner && "pool" in owner)) throw new Error(`AVD ${candidate.name} is in the emulator pool; its data was kept.`);
-		assertOwnedAvdStopped(candidate.name, { resolveDirectory: () => candidate.directory });
+		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 destination = join(dirname(candidate.directory), `stim-gc-${randomUUID()}.avd`);
 		renameSync(candidate.directory, destination);
 		return destination;
@@ -896,14 +990,31 @@ function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
 		label: avdName
 	};
 }
-function teardownOwnedAvd(avdName, { del = false, park, owner, orphanedDirectory, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = assertOwnedAvdStopped, resolveAvd = resolveOwnedAvdSerial } = {}) {
-	let parkFallback;
+function teardownOwnedAvd(avdName, options = {}) {
+	if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return {
+		status: "skipped",
+		kind: "not-owned",
+		reason: `AVD ${avdName} is not Stim-owned by name`
+	};
+	let claim;
 	try {
-		if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return {
-			status: "skipped",
-			kind: "not-owned",
-			reason: `AVD ${avdName} is not Stim-owned by name`
+		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 teardownClaimedAvd(avdName, claim, { del = false, park, owner, orphanedDirectory, onlyIfMissing = false, waitForShutdown = waitForAndroidEmulatorShutdown, assertStopped = assertOwnedAvdStopped, resolveAvd = resolveOwnedAvdSerial }) {
+	let parkFallback;
+	try {
+		if (del) withConfigLock(() => assertAvdReferences(avdName, owner));
 		const resolved = resolveAvd(avdName);
 		if (resolved.notOwned) return {
 			status: "skipped",
@@ -911,13 +1022,34 @@ function teardownOwnedAvd(avdName, { del = false, park, owner, orphanedDirectory
 			reason: `AVD ${avdName} is not Stim-owned by name`
 		};
 		if (resolved.missing) 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;
-		if (serial) waitForShutdown(avdName, (timeoutMs) => shutdownAndroidEmulator(serial, timeoutMs));
-		else assertStopped(avdName);
+		if (serial) {
+			const stillOwned = () => {
+				const current = resolveAvd(avdName);
+				return !current.notOwned && !current.missing && current.serial === serial;
+			};
+			closeOwnedDeviceSessions({
+				platform: "android",
+				id: serial
+			}, stillOwned);
+			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);
+				}
+			});
+		} else assertStopped(avdName);
 		if (del) {
 			const current = resolveAvd(avdName);
 			if (current.notOwned) return {
@@ -928,6 +1060,7 @@ function teardownOwnedAvd(avdName, { del = false, park, owner, orphanedDirectory
 			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");
@@ -972,7 +1105,12 @@ function teardownOwnedAvd(avdName, { del = false, park, owner, orphanedDirectory
 			const directory = ownedAvdDirectory(avdName);
 			const paths = avdStorageRoots().map((root) => join(root, `${avdName}.ini`));
 			if (directory) paths.push(directory);
-			deleteAvd(avdName);
+			(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(", ")}.`);
 		}
@@ -990,4 +1128,4 @@ function teardownOwnedAvd(avdName, { del = false, park, owner, orphanedDirectory
 	}
 }
 //#endregion
-export { uploadRemote as C, resolveRemote as S, isEasAuthFailureText as _, POOL_SETTING_REMEDY as a, providerFromConfig as b, parkedMaxSetting as c, RESOLVE_TIMEOUT_MS as d, UPLOAD_TIMEOUT_MS as f, exitAfterFlush as g, easAuthNote as h, teardownParkedIosSim as i, readParked as l, checkEasAuth as m, teardownOwnedIosSim as n, adoptParked as o, cacheLevel as p, teardownParkedAvd as r, dropParked as s, teardownOwnedAvd as t, selectParked as u, loadProjectProvider as v, resolveEasCliBin as x, ownerFromConfig as y };
+export { resolveRemote as C, resolveEasCliBin as S, exitAfterFlush as _, POOL_SETTING_REMEDY as a, ownerFromConfig as b, isLegacyDeletionClaim as c, selectParked as d, RESOLVE_TIMEOUT_MS as f, easAuthNote as g, checkEasAuth as h, teardownParkedIosSim as i, parkedMaxSetting as l, cacheLevel as m, teardownOwnedIosSim as n, adoptParked as o, UPLOAD_TIMEOUT_MS as p, teardownParkedAvd as r, dropParked as s, teardownOwnedAvd as t, readParked as u, isEasAuthFailureText as v, uploadRemote as w, providerFromConfig as x, loadProjectProvider as y };

package/dist/{workspace-process-lock-3NcQnZ0X.mjs → workspace-process-lock-UEIrvZMJ.mjs}

@@ -1,4 +1,4 @@
-import { f as releaseClaim, h as tryAcquireClaim } from "./ownership-claim-Bf2CAfw3.mjs";
+import { E as ownership_claim_exports } from "./config-6vdGngKa.mjs";
 import { join } from "node:path";
 //#region src/engine/workspace-process-lock.ts
 const DEFAULT_WAIT_MS = 6e4;
@@ -17,17 +17,17 @@ async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep
 	const path = lockPath(root, name, external);
 	const deadline = now() + waitMs;
 	for (;;) {
-		const attempt = tryAcquireClaim({
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
 			root: path,
 			mode: "exclusive",
 			label: `${name} lock`,
 			details: ownerPurpose ? { purpose: ownerPurpose } : {}
 		});
-		if (attempt.pending) releaseClaim(attempt.pending);
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
 		if (attempt.acquired) try {
 			return await fn();
 		} finally {
-			releaseClaim(attempt.acquired);
+			(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
 		}
 		const purpose = (attempt.held ?? attempt.waitingFor?.[0])?.details.purpose;
 		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {

package/dist/workspace-state-Do1e2mOH.mjs

@@ -0,0 +1,146 @@
+import { D as withDirLock, u as getConfigDir } from "./config-6vdGngKa.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { join as join$1, resolve as resolve$1 } from "path";
+import { buildCacheRoot as sharedBuildCache, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+//#region src/paths.ts
+const WORKSPACE_METADATA_FILE_NAME = "workspace.json";
+function workspaceMetadataFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
+}
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve$1(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	mkdirSync(dir, { recursive: true });
+	return withDirLock(join$1(dir, "metadata.lock"), () => {
+		if (!existsSync(file)) {
+			const metadata = {
+				projectRoot: canonicalRoot,
+				workspace: workspaceName$1(canonicalRoot),
+				version: 1
+			};
+			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
+			try {
+				renameSync(tmp, file);
+			} catch (error) {
+				rmSync(tmp, { force: true });
+				throw error;
+			}
+			return dir;
+		}
+		try {
+			if (JSON.parse(readFileSync(file, "utf-8")).projectRoot === canonicalRoot) return dir;
+		} catch {}
+		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
+		error.code = "STIM_WORKSPACE_COLLISION";
+		throw error;
+	});
+}
+function workspaceLogsDir(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "logs");
+}
+function workspaceDerivedData(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "derived-data");
+}
+function supervisorPidFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "supervisor.pid");
+}
+function workspaceStateFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "state.json");
+}
+function workspaceStateLock(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "state.lock");
+}
+function supervisorLogFile(projectRoot) {
+	return join$1(workspaceLogsDir(projectRoot), "supervisor.log");
+}
+function emulatorLogFile(projectRoot) {
+	return join$1(workspaceLogsDir(projectRoot), "emulator.log");
+}
+function sharedCompilationCache() {
+	return join$1(getConfigDir(), "compilation-cache");
+}
+function sharedCcache() {
+	return join$1(getConfigDir(), "ccache");
+}
+//#endregion
+//#region src/workspace-state.ts
+function readWorkspaceState(root) {
+	try {
+		const parsed = JSON.parse(readFileSync(workspaceStateFile(root), "utf-8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function withWorkspaceStateLock(root, fn) {
+	const file = workspaceStateFile(root);
+	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
+		ensureWorkspaceStorage(root);
+		mkdirSync(dirname(file), { recursive: true });
+	} });
+}
+function writeWorkspaceState(root, patch) {
+	return updateWorkspaceState(root, (state) => ({
+		...state,
+		...patch
+	}));
+}
+function updateWorkspaceState(root, update) {
+	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
+}
+function replaceWorkspaceState(root, state) {
+	const file = workspaceStateFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+	renameSync(tmp, file);
+	return state;
+}
+function clearWorkspaceStateKeys(root, keys) {
+	if (!existsSync(workspaceStateFile(root))) return;
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		const file = workspaceStateFile(root);
+		if (!state) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return;
+		}
+		let changed = false;
+		for (const key of keys) {
+			if (!(key in state)) continue;
+			delete state[key];
+			changed = true;
+		}
+		if (!changed) return;
+		if (Object.keys(state).length === 0) {
+			rmSync(file, { force: true });
+			return;
+		}
+		replaceWorkspaceState(root, state);
+	});
+}
+function clearWorkspaceStateKey(root, key, shouldClear) {
+	return withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root);
+		if (!state || !(key in state)) return true;
+		if (!shouldClear(state[key])) return false;
+		delete state[key];
+		const file = workspaceStateFile(root);
+		if (Object.keys(state).length === 0) {
+			try {
+				rmSync(file, { force: true });
+			} catch {}
+			return true;
+		}
+		replaceWorkspaceState(root, state);
+		return true;
+	});
+}
+//#endregion
+export { workspaceLogsDir as _, withWorkspaceStateLock as a, ensureWorkspaceStorage as c, sharedCompilationCache as d, supervisorLogFile as f, workspaceId as g, workspaceDir as h, updateWorkspaceState as i, sharedBuildCache as l, workspaceDerivedData as m, clearWorkspaceStateKeys as n, writeWorkspaceState as o, supervisorPidFile as p, readWorkspaceState as r, emulatorLogFile as s, clearWorkspaceStateKey as t, sharedCcache as u, workspaceName$1 as v, workspaceStateFile as y };