stim 1.8.0 → 1.9.0

package/dist/{device-remote-ByN8P6CB.mjs → device-remote-AQ5rQPqr.mjs}

@@ -1,16 +1,428 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { D as withDirLock, u as getConfigDir } from "./config-B7iyKWkL.mjs";
-import { _ as workspaceLogsDir, h as workspaceDir, v as workspaceName, y as workspaceStateFile } from "./workspace-state-BT5E3SA2.mjs";
-import { a as clearRemoteSession, l as readRemoteSession, s as readMetroTunnel } from "./state-DZobzxLW.mjs";
-import { i as pidExists } from "./metro-C7bcJ0uo.mjs";
-import { z as planMetroReach } from "./settings-BXXorVM2.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
-import { T as readMetroRecords, a as LAUNCH_ERROR, b as isBundleProof, p as devClientDeepLink, r as INSTALL_ERROR } from "./app-install-BDbsSgCl.mjs";
-import { S as sanitizeDeviceLabel } from "./ios-BcCiI4TS.mjs";
+import { A as withDirLock, K as projectDeviceSlots, N as readJsonObject, O as acquireAvdClaim, T as withConfigLock, U as deviceSlotPlatforms, g as loadConfig, k as ownership_claim_exports, u as getConfigDir } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { S as workspaceStateFile, _ as workspaceDir, b as workspaceLogsDir, v as workspaceId, x as workspaceName } from "./workspace-state-DF2gCFhx.mjs";
+import { c as ownedDeviceLabel } from "./project-DS112DYB.mjs";
+import { a as clearRemoteSession, l as readRemoteSession, s as readMetroTunnel } from "./state-NcJzMEBF.mjs";
+import { a as pidExists } from "./metro-DrLHaMn2.mjs";
+import { G as planMetroReach } from "./settings-D030k0t4.mjs";
+import { A as ownedAvdMatchesConfiguration, B as shutdownAndroidEmulator, E as listOrphanedAvdDirectories, N as ownedAvdSystemImage, R as resolveOwnedAvdSerial, V as waitForAndroidEmulatorShutdown, f as avdStorageRoots, g as deleteAvd, k as ownedAvdDirectory, l as assertOwnedAvdStopped, u as avdPathExists } from "./android-_y4Ohi5z.mjs";
+import { l as phaseLine } from "./command-output-gByVmIjy.mjs";
+import { a as parkSim, c as removeParkedAfter, s as readParked } from "./sim-pool-KaIsp2Ft.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
+import { c as readMetroRecords, o as isBundleProof } from "./launch-verify-Q_OtW1Rf.mjs";
+import { a as LAUNCH_ERROR, i as INSTALL_ERROR, l as devClientDeepLink } from "./app-install-Uf3a83Tv.mjs";
+import { C as resolveOwnedIosSim, T as shutdownIosSim, _ as parseRuntimeVersion, a as deleteIosSim, f as listIosDeviceTypes, g as parkedSimName, o as deleteParkedIosSim, r as clearAppDataContainer, s as findAppDataContainer, w as sanitizeDeviceLabel, y as renameIosSim } from "./ios-BL2NFckr.mjs";
 import { t as probePublicHttp } from "./public-http-probe-CyMDrQ3c.mjs";
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
 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: 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.findExecutable("agent-device")) 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/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 parkOwnedIosSim(udid, park) {
+	const resolved = resolveOwnedIosSim(udid);
+	if (resolved.missing) throw new Error(`simulator ${udid} disappeared after shutdown`);
+	if (resolved.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(resolved.notOwned)}`);
+	const sim = resolved.sim;
+	if (sim.state !== "Shutdown") throw new Error(`simulator ${udid} is still ${sim.state} after shutdown`);
+	const model = listIosDeviceTypes().find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null;
+	const runtime = parseRuntimeVersion(sim.runtime);
+	if (park.bundleId) {
+		if (!sim.dataPath) throw new Error(`simulator ${udid} did not report a data path for app cleanup`);
+		const container = findAppDataContainer(sim.dataPath, park.bundleId);
+		if (container) clearAppDataContainer(container);
+	}
+	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.bundleId ? { bundleId: park.bundleId } : {},
+		...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 } = {}) {
+	let parkFallback;
+	try {
+		const resolved = resolveOwnedIosSim(udid);
+		if (resolved.notOwned) return {
+			status: "skipped",
+			kind: "not-owned",
+			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 {
+			const { record, evicted } = parkOwnedIosSim(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 } : {}
+		};
+	} 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 destination = join(dirname(candidate.directory), `stim-gc-${randomUUID()}.avd`);
+		renameSync(candidate.directory, destination);
+		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 });
+	}
+}
+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 = {}) {
+	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 {
+		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",
+			kind: "not-owned",
+			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) {
+			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 {
+				status: "skipped",
+				kind: "not-owned",
+				reason: `AVD ${avdName} is not Stim-owned by name`
+			};
+			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()
+					}
+				});
+				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)
+		};
+	}
+}
+//#endregion
 //#region src/engine/metro-gate.ts
 const REMOTE_METRO_WRONG = "STIM_REMOTE_METRO_WRONG";
 const GATE_TIMEOUT_MS = 25e3;
@@ -81,7 +493,9 @@ function remoteProfile({ daemon, platform, label }) {
 		session: scope,
 		tenant: scope,
 		runId: scope,
-		sessionIsolation: "tenant"
+		sessionIsolation: "tenant",
+		leaseProvider: "proxy",
+		clientId: scope
 	};
 }
 function daemonEnv(daemon) {
@@ -559,7 +973,9 @@ function resolveMetroOrigin({ metroPort, publicUrl = null, mode = "auto", isExpo
 }
 function describe(err) {
 	const e = err;
-	return (typeof e?.stderr === "string" ? e.stderr.trim() : "") || String(e?.message ?? err);
+	const stderr = typeof e?.stderr === "string" ? e.stderr.trim() : "";
+	if (err?.code === "ETIMEDOUT") return String(e?.message ?? err);
+	return stderr || String(e?.message ?? err);
 }
 const PROXY_CREDENTIAL_ENV = ["AGENT_DEVICE_DAEMON_BASE_URL", "AGENT_DEVICE_DAEMON_AUTH_TOKEN"];
 function easExecOptions(root) {
@@ -569,6 +985,9 @@ function easExecOptions(root) {
 	};
 }
 const EAS_OPERATION_TIMEOUT_MS = 3e4;
+const EAS_SESSION_CREATE_TIMEOUT_MS = 6e5;
+const AGENT_DEVICE_TIMEOUT_MS = 12e4;
+const AGENT_DEVICE_INSTALL_TIMEOUT_MS = 6e5;
 function easBoundedExecOptions(root) {
 	return {
 		...easExecOptions(root),
@@ -643,8 +1062,22 @@ function remoteDeviceDeps(ctx) {
 						label: ctx.label,
 						platform: ctx.platform ?? "ios",
 						maxDurationMinutes: ctx.maxDurationMinutes ?? null
-					}), easEnv);
+					}), {
+						...easEnv,
+						timeoutMs: EAS_SESSION_CREATE_TIMEOUT_MS,
+						killSignal: "SIGKILL"
+					});
 				} catch (err) {
+					if (err?.code === "ETIMEDOUT") {
+						const partial = parseCreatedSession(String(err.stdout ?? ""));
+						if (partial) return abandonSession(ctx, partial.id, `eas sim did not finish within ${EAS_SESSION_CREATE_TIMEOUT_MS / 6e4} minutes after creating session ${partial.id}.`);
+						const name = ownedSessionName(ctx.label);
+						return {
+							failed: true,
+							reason: `eas sim did not finish within ${EAS_SESSION_CREATE_TIMEOUT_MS / 6e4} minutes and the eas process was killed. EAS may still have started session ${name}; it has no Stim ownership claim, so \`stim gc\` will not stop it.`,
+							remedy: `Run \`eas simulator:list --name ${name}\` and stop any running session with \`eas simulator:stop --id <id>\`, then retry.`
+						};
+					}
 					return {
 						failed: true,
 						reason: `eas sim failed: ${describe(err)}`
@@ -674,13 +1107,17 @@ function remoteDeviceDeps(ctx) {
 			try {
 				getExecutor().runFile(ctx.agentDeviceBin, closeArgs(profilePath), {
 					cwd: ctx.root,
-					env: daemonEnv(daemon)
+					env: daemonEnv(daemon),
+					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+					killSignal: "SIGKILL"
 				});
 			} catch {}
 			try {
 				getExecutor().runFile(ctx.agentDeviceBin, connectArgs(profilePath), {
 					cwd: ctx.root,
-					env: daemonEnv(daemon)
+					env: daemonEnv(daemon),
+					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+					killSignal: "SIGKILL"
 				});
 			} catch (err) {
 				if (createdHere) return abandonSession(ctx, createdHere, `agent-device connect failed: ${describe(err)}`);
@@ -706,7 +1143,9 @@ function remoteDeviceDeps(ctx) {
 			try {
 				getExecutor().runFile(ctx.agentDeviceBin, installArgs(session.profilePath, artifactPath), {
 					cwd: ctx.root,
-					env: daemonEnv(session.daemon)
+					env: daemonEnv(session.daemon),
+					timeoutMs: AGENT_DEVICE_INSTALL_TIMEOUT_MS,
+					killSignal: "SIGKILL"
 				});
 				return {
 					ok: true,
@@ -725,7 +1164,9 @@ function remoteDeviceDeps(ctx) {
 			if (metroPort === null) try {
 				getExecutor().runFile(ctx.agentDeviceBin, openArgs(session.profilePath, appId, null, null), {
 					cwd: ctx.root,
-					env: daemonEnv(session.daemon)
+					env: daemonEnv(session.daemon),
+					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+					killSignal: "SIGKILL"
 				});
 				return {
 					ok: true,
@@ -753,12 +1194,16 @@ function remoteDeviceDeps(ctx) {
 			try {
 				getExecutor().runFile(ctx.agentDeviceBin, openArgs(session.profilePath, appId, url, metroHintFrom(origin.origin)), {
 					cwd: ctx.root,
-					env: daemonEnv(session.daemon)
+					env: daemonEnv(session.daemon),
+					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+					killSignal: "SIGKILL"
 				});
 				if (url) try {
 					getExecutor().runFile(ctx.agentDeviceBin, acceptAlertArgs(session.profilePath), {
 						cwd: ctx.root,
-						env: daemonEnv(session.daemon)
+						env: daemonEnv(session.daemon),
+						timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+						killSignal: "SIGKILL"
 					});
 				} catch {}
 				return {
@@ -791,7 +1236,7 @@ function remoteDeviceDeps(ctx) {
 		webPreviewUrl: () => session?.daemon.webPreviewUrl ?? null
 	};
 }
-async function resolveRemoteContext({ root, label, backend, platform = "ios", easBin, env = process.env, lookupAgentDevice = defaultLookupAgentDevice, maxDurationMinutes = null }) {
+async function resolveRemoteContext({ root, backend, platform = "ios", easBin, env = process.env, lookupAgentDevice = defaultLookupAgentDevice, maxDurationMinutes = null }) {
 	const agentDeviceBin = lookupAgentDevice();
 	if (!agentDeviceBin) return {
 		failed: "agent-device is not on PATH, and it is what drives a remote device.",
@@ -827,7 +1272,7 @@ async function resolveRemoteContext({ root, label, backend, platform = "ios", ea
 	};
 	return { ctx: {
 		root,
-		label,
+		label: `${ownedDeviceLabel(root)}-${workspaceId(root)}`,
 		backend,
 		platform,
 		easBin: easBin ?? "",
@@ -915,7 +1360,7 @@ function withRemoteSessionLock(root, fn, options = {}) {
 		...options
 	});
 }
-async function ensureRemoteBootOwned({ root, platform, sessionName, startedAt, boot, createdSessionId, abandonCreatedSession, writeState, register = () => {}, withProjectLock = withEasProjectLock, withLock = withRemoteSessionLock, removeEasSessionClaim: removeClaim = removeEasSessionClaim, ledgerRoot = easMachineStateRoot() }) {
+async function ensureRemoteBootOwned({ root, platform, sessionName, startedAt, boot, createdSessionId, abandonCreatedSession, webPreviewUrl = () => null, writeState, register = () => {}, withProjectLock = withEasProjectLock, withLock = withRemoteSessionLock, removeEasSessionClaim: removeClaim = removeEasSessionClaim, ledgerRoot = easMachineStateRoot() }) {
 	try {
 		return await withProjectLock(root, () => withLock(root, async () => {
 			register();
@@ -932,10 +1377,12 @@ async function ensureRemoteBootOwned({ root, platform, sessionName, startedAt, b
 					workspaceHome: getConfigDir(),
 					stateFile: workspaceStateFile(root)
 				}, ledgerRoot);
+				const preview = webPreviewUrl();
 				writeState(root, { remoteDevice: {
 					platform,
 					sessionId,
-					startedAt
+					startedAt,
+					...preview ? { webPreviewUrl: preview } : {}
 				} });
 				return booted;
 			} catch (err) {
@@ -1091,7 +1538,11 @@ function endRecordedSession({ root, sessionId, easBin, lookupAgentDevice, ledger
 function teardownRemote(ctx, { sessionId }) {
 	const profilePath = remoteProfilePath(ctx.root);
 	try {
-		getExecutor().runFile(ctx.agentDeviceBin, disconnectArgs(profilePath), { cwd: ctx.root });
+		getExecutor().runFile(ctx.agentDeviceBin, disconnectArgs(profilePath), {
+			cwd: ctx.root,
+			timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
+			killSignal: "SIGKILL"
+		});
 	} catch {}
 	if (!sessionId) return { status: "torn-down" };
 	const ledger = readEasSessionLedger(ctx.easLedgerRoot);
@@ -1202,16 +1653,12 @@ async function ensureMetroReachable({ ctx, metroPort, isExpo, tunnelMode = "auto
 }
 function bundleEntryPoint(root, isExpo) {
 	if (!isExpo) return "index";
-	try {
-		const pkg = JSON.parse(readFileSync(resolve(root, "package.json"), "utf-8"));
-		if (typeof pkg.main !== "string" || !pkg.main.trim()) return "index";
-		const main = pkg.main.trim();
-		const local = main.startsWith(".") || /\.[cm]?[jt]sx?$/.test(main) || existsSync(resolve(root, main));
-		const normalized = main.replace(/^\.\//, "").replace(/\.(?:[cm]?[jt]sx?)$/, "");
-		return local ? normalized : `node_modules/${normalized}`;
-	} catch {
-		return "index";
-	}
+	const declared = readJsonObject(resolve(root, "package.json"))?.main;
+	if (typeof declared !== "string" || !declared.trim()) return "index";
+	const main = declared.trim();
+	const local = main.startsWith(".") || /\.[cm]?[jt]sx?$/.test(main) || existsSync(resolve(root, main));
+	const normalized = main.replace(/^\.\//, "").replace(/\.(?:[cm]?[jt]sx?)$/, "");
+	return local ? normalized : `node_modules/${normalized}`;
 }
 //#endregion
-export { verifyStoppedSession as C, stopSessionArgs as S, inspectSessionForTeardown as _, ensureMetroReachable as a, ownedSessionName as b, remoteIosDeps as c, withEasProjectLock as d, easMachineStateRoot as f, getSessionArgs as g, findOrphanedOwnedSessions as h, endRecordedSession as i, resolveRemoteContext as l, removeEasSessionClaim as m, binOnPath as n, ensureRemoteBootOwned as o, readEasSessionLedger as p, bundleEntryPoint as r, remoteAndroidDeps as s, REMOTE_SESSION_ERROR as t, withRemoteSessionLock as u, isDefinitiveMissingSessionError as v, gateMetroOrigin as w, parseSessionListPage as x, listOwnedSessionsArgs as y };
+export { verifyStoppedSession as C, teardownParkedAvd as D, teardownOwnedIosSim as E, teardownParkedIosSim as O, stopSessionArgs as S, teardownOwnedAvd as T, inspectSessionForTeardown as _, ensureMetroReachable as a, ownedSessionName as b, remoteIosDeps as c, withEasProjectLock as d, easMachineStateRoot as f, getSessionArgs as g, findOrphanedOwnedSessions as h, endRecordedSession as i, resolveRemoteContext as l, removeEasSessionClaim as m, binOnPath as n, ensureRemoteBootOwned as o, readEasSessionLedger as p, bundleEntryPoint as r, remoteAndroidDeps as s, REMOTE_SESSION_ERROR as t, withRemoteSessionLock as u, isDefinitiveMissingSessionError as v, gateMetroOrigin as w, parseSessionListPage as x, listOwnedSessionsArgs as y };