stim 1.20.2 → 1.22.0

package/dist/device-remote-xRT0Vmo9.mjs

@@ -1,1272 +0,0 @@
-import { d as getConfigDir } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { st as planMetroReach } from "./settings-B717odTD.mjs";
-import { E as workspaceStateFile, S as workspaceId, w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { a as formatElapsed } from "./command-output-BTy8hZ0F.mjs";
-import { N as readRemoteSession, O as clearRemoteSession, j as readMetroTunnel, o as ownedDeviceLabel } from "./project-_phNIJfs.mjs";
-import { s as pidExists } from "./metro-DnCEjCxs.mjs";
-import { N as probePublicHttp } from "./workspaces-C36s2jb9.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-4WopRPg-.mjs";
-import { v as nativeRunWaitNotice } from "./tailnet-Dh-qiYzG.mjs";
-import { D as sanitizeDeviceLabel } from "./ios-RkW4pnQf.mjs";
-import { c as readMetroRecords, o as isBundleProof } from "./launch-verify-B6Q8hZP-.mjs";
-import { d as devClientDeepLink, i as INSTALL_ERROR, o as LAUNCH_ERROR } from "./app-install-BIKtMfPq.mjs";
-import { a as removeEasSessionClaim, i as recordEasSessionClaim, n as easMachineStateRoot$1, o as compareStimVersions, r as readEasSessionLedger$1, t as assertEasMachineRootWritable } from "./eas-session-ledger-Cm0Gwq2F.mjs";
-import { existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { readJsonObject } from "@stim-cli/core/state";
-//#region src/engine/metro-gate.ts
-const REMOTE_METRO_WRONG = "STIM_REMOTE_METRO_WRONG";
-const GATE_TIMEOUT_MS = 25e3;
-const POLL_MS = 250;
-function probeBundleUrl(origin, platform, entryPoint = "index") {
-	const entry = entryPoint.replace(/^\/+/, "").replace(/\.(?:[cm]?[jt]sx?)$/, "");
-	return `${origin.replace(/\/+$/, "")}/${entry}.bundle?platform=${platform}&dev=true`;
-}
-async function gateMetroOrigin({ origin, metroPort, platform, entryPoint = "index", readRecords, isProof, probe = probePublicHttp, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), timeoutMs = GATE_TIMEOUT_MS }) {
-	const since = now();
-	const controller = new AbortController();
-	const bundleUrl = probeBundleUrl(origin, platform, entryPoint);
-	let status = null;
-	let pending = false;
-	let request = Promise.resolve();
-	const startProbe = () => {
-		pending = true;
-		request = (async () => {
-			try {
-				status = await probe(bundleUrl, controller.signal);
-			} catch {
-				status = null;
-			} finally {
-				pending = false;
-			}
-		})();
-	};
-	startProbe();
-	try {
-		const deadline = now() + timeoutMs;
-		while (now() < deadline) {
-			for (const record of readRecords()) if (isProof(record, since)) return { ok: true };
-			if (!pending && status === null) startProbe();
-			await sleep(POLL_MS);
-		}
-	} finally {
-		controller.abort();
-	}
-	await request;
-	return {
-		failed: true,
-		code: REMOTE_METRO_WRONG,
-		reason: describeMiss(origin, metroPort, status),
-		remedy: `Check that ${origin} forwards to port ${metroPort} on THIS machine. A tunnel built for a port this workspace no longer holds will answer normally and serve a different project. \`stim start\` prints the port it reserved.`
-	};
-}
-function describeMiss(origin, metroPort, status) {
-	if (status === null) return `${origin} did not answer, so it cannot be this workspace's Metro (port ${metroPort}).`;
-	if (status >= 500) return `${origin} answered ${status}, so it reached a tunnel but not a dev server (port ${metroPort} may no longer be forwarded).`;
-	return `${origin} answered ${status}, but the request never reached THIS workspace's Metro on port ${metroPort} -- it is serving a different dev server.`;
-}
-//#endregion
-//#region src/engine/agent-device.ts
-const DAEMON_TOKEN_ENV = "AGENT_DEVICE_DAEMON_AUTH_TOKEN";
-const PROFILE_FILE = "agent-device.remote.json";
-function sessionNameFor(label) {
-	return `stim-${sanitizeDeviceLabel(label)}`;
-}
-function remoteProfilePath(root) {
-	return join(workspaceDir(root), PROFILE_FILE);
-}
-function remoteProfile({ daemon, platform, label }) {
-	const scope = sessionNameFor(label);
-	return {
-		daemonBaseUrl: daemon.baseUrl,
-		daemonTransport: "http",
-		platform,
-		session: scope,
-		tenant: scope,
-		runId: scope,
-		sessionIsolation: "tenant",
-		...platform === "android" ? {
-			leaseProvider: "proxy",
-			clientId: scope
-		} : {}
-	};
-}
-function daemonEnv(daemon) {
-	return { [DAEMON_TOKEN_ENV]: daemon.token };
-}
-function withProfile(profilePath, args) {
-	return [
-		...args,
-		"--remote-config",
-		profilePath
-	];
-}
-function connectArgs(profilePath) {
-	return withProfile(profilePath, ["connect", "--force"]);
-}
-function installArgs(profilePath, artifactPath) {
-	return withProfile(profilePath, ["install", artifactPath]);
-}
-function openArgs(profilePath, bundleId, url, metro = null) {
-	const positional = url ? [bundleId, url] : [bundleId];
-	const hint = metro ? [
-		"--metro-host",
-		metro.host,
-		"--metro-port",
-		metro.port
-	] : [];
-	return withProfile(profilePath, [
-		"open",
-		...positional,
-		"--relaunch",
-		...hint
-	]);
-}
-function metroHintFrom(origin) {
-	let url;
-	try {
-		url = new URL(origin);
-	} catch {
-		return null;
-	}
-	const port = url.port || (url.protocol === "https:" ? "443" : url.protocol === "http:" ? "80" : "");
-	return port ? {
-		host: url.hostname,
-		port
-	} : null;
-}
-function acceptAlertArgs(profilePath) {
-	return withProfile(profilePath, ["alert", "accept"]);
-}
-function disconnectArgs(profilePath) {
-	return withProfile(profilePath, ["disconnect"]);
-}
-function closeArgs(profilePath) {
-	return withProfile(profilePath, ["close"]);
-}
-const HEALTH_TIMEOUT_MS = 3e3;
-function archField(value) {
-	if (!value || typeof value !== "object") return null;
-	const arch = value.hostArch;
-	return arch === "arm64" || arch === "x86_64" ? arch : null;
-}
-/** agent-device proxies report the daemon machine under `upstream`; a daemon reports itself at the top level. */
-function parseHealthHostArch(body) {
-	if (!body || typeof body !== "object") return null;
-	return archField(body.upstream) ?? archField(body);
-}
-async function readRemoteSimulatorArch(daemon, { fetch: fetchImpl = fetch, timeoutMs = HEALTH_TIMEOUT_MS } = {}) {
-	if (!daemon) return "arm64";
-	try {
-		const response = await fetchImpl(`${daemon.baseUrl.replace(/\/+$/, "")}/health`, { signal: AbortSignal.timeout(timeoutMs) });
-		if (!response.ok) return "arm64";
-		return parseHealthHostArch(await response.json()) ?? "arm64";
-	} catch {
-		return "arm64";
-	}
-}
-//#endregion
-//#region src/engine/eas-simulator.ts
-const OWNED_PREFIX = "stim-";
-const LIVE_STATUSES$1 = ["new", "in-progress"];
-const LIVE_SESSION_STATUSES = /* @__PURE__ */ new Set(["NEW", "IN_PROGRESS"]);
-const TERMINAL_SESSION_STATUSES = /* @__PURE__ */ new Set(["STOPPED", "ERRORED"]);
-const SESSION_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
-const MIN_EAS_CLI_SIMULATOR_VERSION = "21.6.0";
-const MIN_EAS_CLI_DEVICE_VERSION = "22.2.0";
-function easCliUpgradeRemedy(minimum) {
-	return `Upgrade eas-cli to ${minimum} or later (\`npm install --global eas-cli@latest\`, or the project's eas-cli dependency)`;
-}
-function easCliSupport(versionOutput, minimum) {
-	const version = /\beas-cli\/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(versionOutput ?? "")?.[1] ?? null;
-	const order = version ? compareStimVersions(version, minimum) : null;
-	return {
-		supported: order !== null && order >= 0,
-		version
-	};
-}
-function ownedSessionName(label) {
-	const clean = sanitizeDeviceLabel(label);
-	return `${OWNED_PREFIX}${clean.startsWith(OWNED_PREFIX) ? clean.slice(5) : clean}`;
-}
-function isOwnedSessionName(name) {
-	return typeof name === "string" && name.startsWith(OWNED_PREFIX);
-}
-function createSessionArgs({ label, platform, maxDurationMinutes = null, device = null }) {
-	const args = [
-		"sim",
-		"--platform",
-		platform,
-		"--json",
-		"--non-interactive",
-		"--out-config-type",
-		"env",
-		"--name",
-		ownedSessionName(label)
-	];
-	if (maxDurationMinutes) args.push("--max-duration-minutes", String(maxDurationMinutes));
-	if (device) args.push("--device", device);
-	return args;
-}
-function getSessionArgs(sessionId) {
-	return [
-		"simulator:get",
-		"--id",
-		sessionId,
-		"--json",
-		"--non-interactive"
-	];
-}
-function stopSessionArgs(sessionId) {
-	return [
-		"simulator:stop",
-		"--id",
-		sessionId,
-		"--json",
-		"--non-interactive"
-	];
-}
-function listOwnedSessionsArgs(after = null) {
-	const args = [
-		"simulator:list",
-		"--name",
-		OWNED_PREFIX,
-		...LIVE_STATUSES$1.flatMap((s) => ["--status", s]),
-		"--limit",
-		"100",
-		"--json",
-		"--non-interactive"
-	];
-	if (after) args.push("--after", after);
-	return args;
-}
-function remoteDaemonFrom(config) {
-	if (!isRecord(config)) return null;
-	const typename = str(config["__typename"]);
-	if (typename && typename !== "AgentDeviceRunSessionRemoteConfig") return null;
-	const baseUrl = str(config.agentDeviceRemoteSessionUrl);
-	const token = str(config.agentDeviceRemoteSessionToken);
-	if (!baseUrl || !token) return null;
-	const daemon = {
-		baseUrl,
-		token
-	};
-	const preview = str(config.webPreviewUrl);
-	if (preview) daemon.webPreviewUrl = preview;
-	return daemon;
-}
-function parseJson(stdout) {
-	try {
-		return JSON.parse(stdout);
-	} catch {
-		return null;
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function str(value) {
-	return typeof value === "string" && value.length > 0 ? value : null;
-}
-function inspectSessionForTeardown(stdout, sessionId) {
-	const data = parseJson(stdout);
-	if (!isRecord(data)) return {
-		action: "refused",
-		reason: `Session ${sessionId} lookup did not return valid JSON.`
-	};
-	const id = str(data.id);
-	if (!id) return {
-		action: "refused",
-		reason: `Session ${sessionId} lookup returned no session id.`
-	};
-	if (id !== sessionId) return {
-		action: "refused",
-		reason: `Session ${sessionId} lookup returned different session ${id}.`
-	};
-	const status = str(data.status);
-	if (!status) return {
-		action: "refused",
-		reason: `Session ${sessionId} lookup returned no status.`
-	};
-	const name = str(data.name);
-	if (!isOwnedSessionName(name)) return {
-		action: "refused",
-		reason: `Session ${sessionId} is not owned by Stim (name: ${name ?? "missing"}).`
-	};
-	if (TERMINAL_SESSION_STATUSES.has(status)) return {
-		action: "already-stopped",
-		name,
-		status
-	};
-	if (!LIVE_SESSION_STATUSES.has(status)) return {
-		action: "refused",
-		reason: `Session ${sessionId} has unknown status ${status}.`
-	};
-	return {
-		action: "stop",
-		name,
-		status
-	};
-}
-function isDefinitiveMissingSessionError(error, sessionId) {
-	const candidate = error;
-	const stderr = typeof candidate?.stderr === "string" ? candidate.stderr : "";
-	const message = typeof candidate?.message === "string" ? candidate.message : "";
-	const escapedSessionId = sessionId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	const missingSession = new RegExp(`(?:device[\\s-]*run[\\s-]*session|simulator[\\s-]*session)[\\s:#]*\\b${escapedSessionId}\\b[\\s,:]*(?:(?:was\\s+)?not\\s+found|does\\s+not\\s+exist)\\b`, "i");
-	return `${stderr}\n${message}`.split(/\r?\n/).map((line) => line.replace(/\s+/g, " ").trim()).some((line) => missingSession.test(line));
-}
-function verifyStoppedSession(stdout, sessionId) {
-	const stopped = parseStoppedSession(stdout);
-	if (!stopped) return {
-		ok: false,
-		reason: `Stop for session ${sessionId} did not return valid JSON with an id.`
-	};
-	if (stopped.id !== sessionId) return {
-		ok: false,
-		reason: `Stop for session ${sessionId} returned different session ${stopped.id}.`
-	};
-	if (!stopped.status || !TERMINAL_SESSION_STATUSES.has(stopped.status)) return {
-		ok: false,
-		reason: `Stop for session ${sessionId} returned unknown status ${stopped.status ?? "missing"}.`
-	};
-	return { ok: true };
-}
-function parseCreatedSession(stdout) {
-	const data = parseJson(stdout);
-	if (!isRecord(data)) return null;
-	const id = str(data.id);
-	if (!id) return null;
-	return {
-		id,
-		name: str(data.name),
-		url: str(data.deviceRunSessionUrl),
-		daemon: remoteDaemonFrom(data.remoteConfig)
-	};
-}
-function parseSessionListPage(stdout) {
-	const data = parseJson(stdout);
-	if (!isRecord(data) || !Array.isArray(data.sessions)) return {
-		ok: false,
-		reason: "EAS session list did not return valid JSON with a sessions array."
-	};
-	if (!isRecord(data.pageInfo) || typeof data.pageInfo.hasNextPage !== "boolean") return {
-		ok: false,
-		reason: "EAS session list page did not return valid pagination information."
-	};
-	const endCursor = data.pageInfo.endCursor;
-	if (endCursor !== null && typeof endCursor !== "string") return {
-		ok: false,
-		reason: "EAS session list returned a malformed pagination cursor."
-	};
-	return {
-		ok: true,
-		page: {
-			sessions: data.sessions,
-			hasNextPage: data.pageInfo.hasNextPage,
-			endCursor
-		}
-	};
-}
-function findOrphanedOwnedSessions({ sessions, recordedSessionIds, projectScope }) {
-	const scope = typeof projectScope === "string" ? projectScope.trim() : "";
-	if (!scope) return {
-		orphaned: [],
-		notices: ["EAS session list has no current-project scope."]
-	};
-	const recorded = new Set(recordedSessionIds.filter((id) => typeof id === "string" && id.length > 0));
-	const candidates = /* @__PURE__ */ new Map();
-	const conflicts = /* @__PURE__ */ new Set();
-	const blocked = /* @__PURE__ */ new Set();
-	const notices = [];
-	for (const raw of sessions) {
-		if (!isRecord(raw)) {
-			notices.push("EAS session list contains a malformed entry.");
-			continue;
-		}
-		const id = str(raw.id);
-		const name = str(raw.name);
-		if (!id) {
-			if (isOwnedSessionName(name)) notices.push("EAS session list contains an owned entry with no session id.");
-			continue;
-		}
-		if (!name) {
-			blocked.add(id);
-			candidates.delete(id);
-			notices.push(`EAS session ${id} has no name and cannot be classified as Stim-owned.`);
-			continue;
-		}
-		if (!isOwnedSessionName(name)) continue;
-		const status = str(raw.status)?.toUpperCase().replace(/-/g, "_") ?? null;
-		if (!status) {
-			blocked.add(id);
-			candidates.delete(id);
-			notices.push(`Owned EAS session ${id} has no status.`);
-			continue;
-		}
-		if (TERMINAL_SESSION_STATUSES.has(status)) continue;
-		if (!LIVE_SESSION_STATUSES.has(status)) {
-			blocked.add(id);
-			candidates.delete(id);
-			notices.push(`Owned EAS session ${id} has unknown status ${status}.`);
-			continue;
-		}
-		const platformValue = str(raw.platform);
-		const normalizedPlatform = platformValue?.toLowerCase() ?? null;
-		if (!normalizedPlatform || !SESSION_PLATFORMS.has(normalizedPlatform)) {
-			blocked.add(id);
-			candidates.delete(id);
-			notices.push(platformValue ? `Owned EAS session ${id} has unknown platform ${platformValue}.` : `Owned EAS session ${id} has no platform.`);
-			continue;
-		}
-		if (recorded.has(id) || blocked.has(id)) continue;
-		const candidate = {
-			id,
-			name,
-			status,
-			platform: normalizedPlatform,
-			projectScope: scope
-		};
-		const previous = candidates.get(id);
-		if (!previous) {
-			candidates.set(id, candidate);
-			continue;
-		}
-		if (previous.name !== candidate.name || previous.status !== candidate.status || previous.platform !== candidate.platform) {
-			conflicts.add(id);
-			candidates.delete(id);
-			notices.push(`EAS session list contains conflicting entries for session ${id}.`);
-		}
-	}
-	for (const id of [...conflicts, ...blocked]) candidates.delete(id);
-	return {
-		orphaned: [...candidates.values()],
-		notices
-	};
-}
-function parseStoppedSession(stdout) {
-	const data = parseJson(stdout);
-	if (!isRecord(data)) return null;
-	const id = str(data.id);
-	if (!id) return null;
-	return {
-		id,
-		status: str(data.status)
-	};
-}
-//#endregion
-//#region src/engine/eas-project-lock.ts
-const EAS_PROJECT_LOCK_WAIT_MS = 24e4;
-function describeEasProjectLockHolder(holder, now) {
-	const { purpose, workspace } = holder.details;
-	const facts = [`pid ${holder.owner.pid}`];
-	if (typeof workspace === "string") facts.push(`in ${workspace}`);
-	const started = Date.parse(holder.startedAt);
-	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
-	return `${typeof purpose === "string" ? purpose : "another Stim EAS operation"} (${facts.join(", ")})`;
-}
-function withEasProjectLock(_root, fn, options = {}) {
-	const { machineRoot = easMachineStateRoot$1(), ...lockOptions } = options;
-	assertEasMachineRootWritable(machineRoot);
-	return withWorkspaceProcessLock(machineRoot, "eas-project", fn, {
-		waitMs: EAS_PROJECT_LOCK_WAIT_MS,
-		...lockOptions,
-		external: true
-	});
-}
-//#endregion
-//#region src/engine/device-remote.ts
-const REMOTE_SESSION_ERROR = "STIM_NO_REMOTE_SESSION";
-const REMOTE_METRO_ERROR = "STIM_REMOTE_METRO_UNREACHABLE";
-function resolveMetroOrigin({ metroPort, publicUrl = null, mode = "auto", isExpo = false, available = [] }) {
-	const plan = planMetroReach({
-		mode,
-		metroPort,
-		publicUrl,
-		isExpo,
-		available
-	});
-	if ("origin" in plan) return plan;
-	if ("failed" in plan) return plan;
-	return {
-		failed: "Metro has no address the device can reach yet.",
-		remedy: "This is a Stim bug: the tunnel step did not run before the launch."
-	};
-}
-function describe(err) {
-	const e = 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) {
-	return {
-		cwd: root,
-		omitEnv: PROXY_CREDENTIAL_ENV
-	};
-}
-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),
-		timeoutMs: EAS_OPERATION_TIMEOUT_MS
-	};
-}
-function writeProfile(ctx, daemon) {
-	const path = remoteProfilePath(ctx.root);
-	mkdirSync(dirname(path), { recursive: true });
-	const profile = remoteProfile({
-		daemon,
-		platform: ctx.platform ?? "ios",
-		label: ctx.label
-	});
-	writeFileSync(path, `${JSON.stringify(profile, null, 2)}\n`);
-	return path;
-}
-function remoteDeviceDeps(ctx) {
-	let session = null;
-	let createdSession = null;
-	const easEnv = easExecOptions(ctx.root);
-	return {
-		checkCapacity: () => null,
-		ensureDevice: async () => ({
-			deviceName: ctx.backend === "proxy" ? "remote device (your daemon)" : "EAS Simulator",
-			owned: true,
-			remote: true
-		}),
-		ensureBooted: async ({ out = () => {} } = {}) => {
-			session = null;
-			createdSession = null;
-			const note = (message) => {
-				try {
-					out(message);
-				} catch {}
-			};
-			let daemon = ctx.existingDaemon ?? null;
-			let id = null;
-			let createdHere = null;
-			if (!daemon) {
-				const recorded = readRemoteSession(ctx.root);
-				if (recorded && recorded.platform !== (ctx.platform ?? "ios")) return {
-					failed: true,
-					code: "STIM_REMOTE_PLATFORM_MISMATCH",
-					reason: `Session ${recorded.sessionId} belongs to ${recorded.platform ?? "an unknown platform"}, not ${ctx.platform ?? "ios"}.`,
-					remedy: "Run `stim stop` for this workspace before selecting a different remote platform."
-				};
-				if (recorded) {
-					const existing = readLiveDaemon(ctx, recorded.sessionId);
-					if (existing && ctx.deviceType && recorded.deviceType !== ctx.deviceType) return {
-						failed: true,
-						code: "STIM_REMOTE_DEVICE_MISMATCH",
-						reason: `EAS Simulator session ${recorded.sessionId} runs ${recorded.deviceType ? `"${recorded.deviceType}"` : "the model EAS chose"}, not "${ctx.deviceType}". Stim will not reuse a session on a different model.`,
-						remedy: `Run \`stim stop\` to end that session, then run \`stim ${ctx.platform ?? "ios"} --remote eas --device-type "${ctx.deviceType}"\` again to start one on the requested model.`
-					};
-					if (existing) {
-						note(`Reusing EAS Simulator session ${recorded.sessionId}.`);
-						daemon = existing;
-						id = recorded.sessionId;
-					} else {
-						note(`Recorded session ${recorded.sessionId} is not usable; verifying it before replacement.`);
-						const cleanup = teardownRemote(ctx, { sessionId: recorded.sessionId });
-						if (cleanup.status === "failed" || cleanup.reason) return {
-							failed: true,
-							code: "STIM_REMOTE_SESSION_CLEANUP",
-							reason: cleanup.reason ?? `Could not verify recorded EAS session ${recorded.sessionId}.`,
-							remedy: "Inspect the recorded session, then run `stim stop` again."
-						};
-						clearRemoteSession(ctx.root, recorded.sessionId);
-					}
-				}
-			}
-			if (!daemon) {
-				note("Creating an EAS Simulator session (this takes a moment).");
-				let stdout;
-				try {
-					stdout = getExecutor().runFile(ctx.easBin, createSessionArgs({
-						label: ctx.label,
-						platform: ctx.platform ?? "ios",
-						maxDurationMinutes: ctx.maxDurationMinutes ?? null,
-						device: ctx.deviceType ?? null
-					}), {
-						...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)}`
-					};
-				}
-				const created = parseCreatedSession(stdout);
-				if (!created) return {
-					failed: true,
-					reason: "eas sim returned no session; run it by hand to see what it reported."
-				};
-				id = created.id;
-				createdHere = created.id;
-				daemon = created.daemon ?? await waitForDaemon(ctx, created.id, note, { sleep: ctx.sleep ?? defaultSleep });
-				if (!daemon) return abandonSession(ctx, created.id, `Session ${created.id} never published an agent-device endpoint. It may be an appium or argent session rather than an agent-device one.`);
-			}
-			let profilePath;
-			try {
-				profilePath = writeProfile(ctx, daemon);
-			} catch (err) {
-				const reason = `Could not write the remote connection profile: ${describe(err)}`;
-				if (createdHere) return abandonSession(ctx, createdHere, reason);
-				return {
-					failed: true,
-					reason
-				};
-			}
-			try {
-				getExecutor().runFile(ctx.agentDeviceBin, closeArgs(profilePath), {
-					cwd: ctx.root,
-					env: daemonEnv(daemon),
-					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
-					killSignal: "SIGKILL"
-				});
-			} catch {}
-			try {
-				getExecutor().runFile(ctx.agentDeviceBin, connectArgs(profilePath), {
-					cwd: ctx.root,
-					env: daemonEnv(daemon),
-					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
-					killSignal: "SIGKILL"
-				});
-			} catch (err) {
-				if (createdHere) return abandonSession(ctx, createdHere, `agent-device connect failed: ${describe(err)}`);
-				return {
-					failed: true,
-					reason: `agent-device connect failed: ${describe(err)}`
-				};
-			}
-			session = {
-				id,
-				daemon,
-				profilePath
-			};
-			createdSession = createdHere;
-			if (daemon.webPreviewUrl) note(`Watch this device: ${daemon.webPreviewUrl}`);
-			return {
-				ok: true,
-				udid: id ?? daemonHostLabel(daemon.baseUrl)
-			};
-		},
-		installArtifact: (artifactPath) => {
-			if (!session) return notConnected(INSTALL_ERROR);
-			try {
-				getExecutor().runFile(ctx.agentDeviceBin, installArgs(session.profilePath, artifactPath), {
-					cwd: ctx.root,
-					env: daemonEnv(session.daemon),
-					timeoutMs: AGENT_DEVICE_INSTALL_TIMEOUT_MS,
-					killSignal: "SIGKILL"
-				});
-				return {
-					ok: true,
-					appPath: artifactPath
-				};
-			} catch (err) {
-				return {
-					failed: true,
-					code: INSTALL_ERROR,
-					reason: `agent-device install failed for ${artifactPath}: ${describe(err)}`
-				};
-			}
-		},
-		launchApp: ({ appId, metroPort, devClientScheme = null }) => {
-			if (!session) return notConnected(LAUNCH_ERROR);
-			if (metroPort === null) try {
-				getExecutor().runFile(ctx.agentDeviceBin, openArgs(session.profilePath, appId, null, null), {
-					cwd: ctx.root,
-					env: daemonEnv(session.daemon),
-					timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
-					killSignal: "SIGKILL"
-				});
-				return {
-					ok: true,
-					mode: "launch"
-				};
-			} catch (err) {
-				return {
-					failed: true,
-					code: LAUNCH_ERROR,
-					reason: `agent-device open ${appId} failed: ${describe(err)}`
-				};
-			}
-			const origin = resolveMetroOrigin({
-				metroPort,
-				publicUrl: ctx.publicMetroUrl ?? null,
-				mode: ctx.tunnelMode ?? "auto",
-				isExpo: ctx.isExpo ?? false
-			});
-			if ("failed" in origin) return {
-				failed: true,
-				code: REMOTE_METRO_ERROR,
-				reason: `${origin.failed} ${origin.remedy}`
-			};
-			const url = devClientScheme ? devClientDeepLink(devClientScheme, origin.origin) : null;
-			try {
-				getExecutor().runFile(ctx.agentDeviceBin, openArgs(session.profilePath, appId, url, metroHintFrom(origin.origin)), {
-					cwd: ctx.root,
-					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),
-						timeoutMs: AGENT_DEVICE_TIMEOUT_MS,
-						killSignal: "SIGKILL"
-					});
-				} catch {}
-				return {
-					ok: true,
-					mode: url ? "openurl" : "launch",
-					url: url ?? void 0,
-					jsLocation: origin.origin
-				};
-			} catch (err) {
-				return {
-					failed: true,
-					code: LAUNCH_ERROR,
-					reason: `agent-device open ${appId} failed: ${describe(err)}`
-				};
-			}
-		},
-		createdSessionId: () => createdSession,
-		abandonCreatedSession: () => {
-			if (!createdSession) return {
-				ok: true,
-				sessionId: null
-			};
-			const stopped = stopCreatedSession(ctx, createdSession);
-			if (stopped.ok) {
-				session = null;
-				createdSession = null;
-			}
-			return stopped;
-		},
-		webPreviewUrl: () => session?.daemon.webPreviewUrl ?? null,
-		failureRemedy: () => ctx.backend === "eas" && session?.id ? `EAS Simulator session ${session.id} is still running and billed until it reaches its time limit or \`stim stop\` ends it. Fix the error above and run this command again to reuse the session, or run \`stim stop\` to end it.` : "Check that the remote daemon is reachable and still has the device, then run this command again."
-	};
-}
-async function resolveRemoteContext({ root, backend, platform = "ios", easBin, env = process.env, lookupAgentDevice = defaultLookupAgentDevice, readEasCliVersion = readInstalledEasCliVersion, maxDurationMinutes = null, deviceType = null }) {
-	const agentDeviceBin = lookupAgentDevice();
-	if (!agentDeviceBin) return {
-		failed: "agent-device is not on PATH, and it is what drives a remote device.",
-		remedy: `Install it (\`npm i -g agent-device\`), then run \`stim ${platform} --remote ${backend}\` again.`
-	};
-	const baseUrl = env.AGENT_DEVICE_DAEMON_BASE_URL?.trim();
-	const token = env.AGENT_DEVICE_DAEMON_AUTH_TOKEN?.trim();
-	let existingDaemon = null;
-	if (backend === "proxy") {
-		if (!baseUrl && !token) return {
-			failed: "The proxy backend requires AGENT_DEVICE_DAEMON_BASE_URL and AGENT_DEVICE_DAEMON_AUTH_TOKEN.",
-			remedy: "Export AGENT_DEVICE_DAEMON_BASE_URL and AGENT_DEVICE_DAEMON_AUTH_TOKEN, then run the device command with `--remote proxy` again.",
-			code: "STIM_REMOTE_PROXY_CONFIG"
-		};
-		if (!baseUrl) return {
-			failed: "The proxy backend requires AGENT_DEVICE_DAEMON_BASE_URL.",
-			remedy: "Export AGENT_DEVICE_DAEMON_BASE_URL, then run the device command with `--remote proxy` again.",
-			code: "STIM_REMOTE_PROXY_CONFIG"
-		};
-		if (!token) return {
-			failed: "The proxy backend requires AGENT_DEVICE_DAEMON_AUTH_TOKEN.",
-			remedy: "Export AGENT_DEVICE_DAEMON_AUTH_TOKEN, then run the device command with `--remote proxy` again.",
-			code: "STIM_REMOTE_PROXY_CONFIG"
-		};
-		existingDaemon = {
-			baseUrl,
-			token
-		};
-	} else if (!easBin) return {
-		failed: "The eas backend requires eas-cli.",
-		remedy: "Install eas-cli, then run the device command with `--remote eas` again.",
-		code: "STIM_REMOTE_EAS_UNAVAILABLE"
-	};
-	else {
-		const versionOutput = readEasCliVersion(easBin, root);
-		const { supported, version } = easCliSupport(versionOutput, MIN_EAS_CLI_SIMULATOR_VERSION);
-		if (!supported) return {
-			failed: version ? `eas-cli ${version} (${easBin}) has no EAS Simulator commands; the eas backend needs eas-cli ${MIN_EAS_CLI_SIMULATOR_VERSION} or later.` : `Could not read an eas-cli version from \`${easBin} --version\`; the eas backend needs eas-cli ${MIN_EAS_CLI_SIMULATOR_VERSION} or later.`,
-			remedy: `${easCliUpgradeRemedy(MIN_EAS_CLI_SIMULATOR_VERSION)}, then run the device command with \`--remote eas\` again.`,
-			code: "STIM_REMOTE_EAS_UNAVAILABLE"
-		};
-		if (deviceType && !easCliSupport(versionOutput, "22.2.0").supported) return {
-			failed: `eas-cli ${version} (${easBin}) cannot choose the EAS Simulator model; --device-type on the eas backend needs eas-cli ${MIN_EAS_CLI_DEVICE_VERSION} or later.`,
-			remedy: `${easCliUpgradeRemedy(MIN_EAS_CLI_DEVICE_VERSION)}, or drop --device-type to let EAS pick the model.`,
-			code: "STIM_BAD_ARG"
-		};
-	}
-	return { ctx: {
-		root,
-		label: `${ownedDeviceLabel(root)}-${workspaceId(root)}`,
-		backend,
-		platform,
-		easBin: easBin ?? "",
-		agentDeviceBin,
-		maxDurationMinutes,
-		deviceType: backend === "eas" ? deviceType : null,
-		publicMetroUrl: null,
-		existingDaemon
-	} };
-}
-function readInstalledEasCliVersion(easBin, root) {
-	try {
-		return getExecutor().runFile(easBin, ["--version"], easBoundedExecOptions(root));
-	} catch {
-		return null;
-	}
-}
-function binOnPath(bin) {
-	try {
-		return Boolean(getExecutor().findExecutable(bin));
-	} catch {
-		return false;
-	}
-}
-function defaultLookupAgentDevice() {
-	const found = getExecutor().findExecutable("agent-device");
-	return (String(found ?? "").split("\n")[0] ?? "").trim() || null;
-}
-const DAEMON_WAIT_MS = 18e4;
-const DAEMON_POLL_MS = 5e3;
-async function waitForDaemon(ctx, sessionId, out, { sleep = defaultSleep } = {}) {
-	const attempts = Math.ceil(DAEMON_WAIT_MS / DAEMON_POLL_MS);
-	for (let attempt = 0; attempt < attempts; attempt++) {
-		const daemon = readDaemon(ctx, sessionId);
-		if (daemon) return daemon;
-		if (attempt === 0) out(`Waiting for session ${sessionId} to become reachable.`);
-		await sleep(DAEMON_POLL_MS);
-	}
-	return null;
-}
-function defaultSleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function stopCreatedSession(ctx, sessionId) {
-	let stopOutput;
-	try {
-		stopOutput = getExecutor().runFile(ctx.easBin, stopSessionArgs(sessionId), easBoundedExecOptions(ctx.root));
-	} catch (err) {
-		return {
-			failed: true,
-			code: "STIM_REMOTE_SESSION_CLEANUP",
-			reason: `Stim could not stop session ${sessionId} (${describe(err)}). The session bills until its cap.`,
-			remedy: `Run \`eas simulator:stop --id ${sessionId}\`.`,
-			sessionId
-		};
-	}
-	const verified = verifyStoppedSession(stopOutput, sessionId);
-	if (!verified.ok) return {
-		failed: true,
-		code: "STIM_REMOTE_SESSION_CLEANUP",
-		reason: `Stim could not verify that session ${sessionId} stopped (${verified.reason}). The session bills until its cap.`,
-		remedy: `Run \`eas simulator:stop --id ${sessionId}\`.`,
-		sessionId
-	};
-	return {
-		ok: true,
-		sessionId
-	};
-}
-function abandonSession(ctx, sessionId, reason) {
-	const stopped = stopCreatedSession(ctx, sessionId);
-	if (stopped.ok) return {
-		failed: true,
-		reason: `${reason} The session was stopped.`
-	};
-	return {
-		failed: true,
-		code: stopped.code,
-		reason: `${reason} ${stopped.reason} ${stopped.remedy}`,
-		remedy: stopped.remedy
-	};
-}
-function withRemoteSessionLock(root, fn, options = {}) {
-	let canonicalRoot;
-	try {
-		canonicalRoot = realpathSync(root);
-	} catch {
-		canonicalRoot = resolve(root);
-	}
-	return withWorkspaceProcessLock(workspaceDir(canonicalRoot), "remote-session", fn, {
-		external: true,
-		waitMs: 24e4,
-		...options
-	});
-}
-const EAS_START_HOLD_MS = 108e4 + Math.ceil(DAEMON_WAIT_MS / DAEMON_POLL_MS) * 35e3;
-async function ensureRemoteBootOwned({ root, platform, sessionName, startedAt, deviceType = null, boot, createdSessionId, abandonCreatedSession, webPreviewUrl = () => null, writeState, register = () => {}, withProjectLock = withEasProjectLock, withLock = withRemoteSessionLock, removeEasSessionClaim: removeClaim = removeEasSessionClaim, ledgerRoot = easMachineStateRoot$1(), notice = () => {}, now = Date.now }) {
-	const waitNotice = nativeRunWaitNotice({
-		write: notice,
-		now,
-		describe: describeEasProjectLockHolder
-	});
-	let stuck = null;
-	let seen = null;
-	let projectLocked = false;
-	try {
-		return await withProjectLock(root, () => {
-			projectLocked = true;
-			return withLock(root, async () => {
-				register();
-				const booted = await boot();
-				if (booted.failed) return booted;
-				const sessionId = createdSessionId();
-				if (!sessionId) return booted;
-				try {
-					recordEasSessionClaim({
-						sessionId,
-						name: sessionName,
-						platform,
-						workspaceRoot: root,
-						workspaceHome: getConfigDir(),
-						stateFile: workspaceStateFile(root)
-					}, ledgerRoot);
-					const preview = webPreviewUrl();
-					writeState(root, { remoteDevice: {
-						platform,
-						sessionId,
-						startedAt,
-						...preview ? { webPreviewUrl: preview } : {},
-						...deviceType ? { deviceType } : {}
-					} });
-					return booted;
-				} catch (err) {
-					const cleanup = abandonCreatedSession();
-					if (cleanup.ok) {
-						let removalFailure = "the claim store did not remove it";
-						try {
-							if (removeClaim(sessionId, ledgerRoot)) return {
-								failed: true,
-								code: "STIM_REMOTE_SESSION_STATE",
-								reason: `Could not record EAS session ${sessionId}: ${describe(err)}. The session was stopped.`,
-								remedy: "Fix workspace state storage, then retry the remote command."
-							};
-						} catch (error) {
-							removalFailure = describe(error);
-						}
-						return {
-							failed: true,
-							code: "STIM_REMOTE_SESSION_CLEANUP",
-							reason: `Could not record EAS session ${sessionId}: ${describe(err)}. The session was stopped, but its ownership claim could not be removed: ${removalFailure}.`,
-							remedy: `The stopped session claim remains under ${ledgerRoot}. Repair that ownership ledger before retrying the remote command.`
-						};
-					}
-					return {
-						failed: true,
-						code: cleanup.code ?? "STIM_REMOTE_SESSION_CLEANUP",
-						reason: `Could not record EAS session ${sessionId}: ${describe(err)}. ${cleanup.reason ?? ""}`.trim(),
-						remedy: cleanup.remedy ?? `Run \`eas simulator:stop --id ${sessionId}\`.`
-					};
-				}
-			});
-		}, {
-			ownerPurpose: "EAS remote start",
-			machineRoot: ledgerRoot,
-			waitMs: Number.POSITIVE_INFINITY,
-			details: {
-				workspace: root,
-				platform
-			},
-			now,
-			onHeld: (holder) => {
-				const at = now();
-				if (seen?.claimId !== holder.claimId) seen = {
-					claimId: holder.claimId,
-					at
-				};
-				const claimedAt = Date.parse(holder.startedAt);
-				const heldMs = at - (Number.isFinite(claimedAt) ? Math.min(claimedAt, seen.at) : seen.at);
-				if (heldMs > EAS_START_HOLD_MS) {
-					stuck = {
-						holder,
-						heldMs
-					};
-					const error = /* @__PURE__ */ new Error(`The eas-project lock was held past ${formatElapsed(EAS_START_HOLD_MS)}.`);
-					error.code = "STIM_LOCK_TIMEOUT";
-					throw error;
-				}
-				waitNotice(holder, `waiting for ${describeEasProjectLockHolder(holder, at)} to release the EAS project lock; one EAS session starts at a time on this machine`);
-			}
-		});
-	} catch (err) {
-		const code = err.code ?? "STIM_NO_REMOTE_SESSION";
-		if (stuck && !projectLocked) {
-			const { holder, heldMs } = stuck;
-			return {
-				failed: true,
-				code,
-				reason: `${describeEasProjectLockHolder(holder, now())} has held the EAS project lock for ${formatElapsed(heldMs)}; an EAS session start holds it for at most ${formatElapsed(EAS_START_HOLD_MS)}.`,
-				remedy: `If pid ${holder.owner.pid} is stuck, stop it, then run the remote command again.`
-			};
-		}
-		return {
-			failed: true,
-			code,
-			reason: describe(err),
-			remedy: "Retry the remote command after the other workspace operation finishes."
-		};
-	}
-}
-function daemonHostLabel(baseUrl) {
-	try {
-		return new URL(baseUrl).host;
-	} catch {
-		return baseUrl;
-	}
-}
-function notConnected(code) {
-	return {
-		failed: true,
-		code,
-		reason: "No remote session is connected; the device step did not complete."
-	};
-}
-const LIVE_STATUSES = /* @__PURE__ */ new Set(["NEW", "IN_PROGRESS"]);
-function readLiveDaemon(ctx, sessionId) {
-	let stdout;
-	try {
-		stdout = getExecutor().runFile(ctx.easBin, getSessionArgs(sessionId), easBoundedExecOptions(ctx.root));
-	} catch {
-		return null;
-	}
-	try {
-		const inspection = inspectSessionForTeardown(stdout, sessionId);
-		if (inspection.action !== "stop" || !LIVE_STATUSES.has(inspection.status)) return null;
-		return remoteDaemonFrom(JSON.parse(stdout).remoteConfig);
-	} catch {
-		return null;
-	}
-}
-function readDaemon(ctx, sessionId) {
-	let stdout;
-	try {
-		stdout = getExecutor().runFile(ctx.easBin, getSessionArgs(sessionId), easBoundedExecOptions(ctx.root));
-	} catch {
-		return null;
-	}
-	try {
-		return remoteDaemonFrom(JSON.parse(stdout).remoteConfig);
-	} catch {
-		return null;
-	}
-}
-function remoteIosDeps(ctx) {
-	const shared = {
-		...ctx,
-		platform: "ios"
-	};
-	const core = remoteDeviceDeps(shared);
-	return {
-		ctx: shared,
-		checkDeviceCapacity: core.checkCapacity,
-		ensureOwnedDevice: core.ensureDevice,
-		ensureBooted: core.ensureBooted,
-		installIosApp: ({ appPath }) => core.installArtifact(appPath),
-		launchIosApp: ({ bundleId, metroPort, devClientScheme }) => core.launchApp({
-			appId: bundleId,
-			metroPort,
-			devClientScheme
-		}),
-		createdSessionId: core.createdSessionId,
-		abandonCreatedSession: core.abandonCreatedSession,
-		webPreviewUrl: core.webPreviewUrl,
-		failureRemedy: core.failureRemedy
-	};
-}
-function remoteAndroidDeps(ctx) {
-	const shared = {
-		...ctx,
-		platform: "android"
-	};
-	const core = remoteDeviceDeps(shared);
-	return {
-		ctx: shared,
-		checkCapacity: core.checkCapacity,
-		ensureDevice: core.ensureDevice,
-		ensureDeviceBooted: async (opts) => {
-			const booted = await core.ensureBooted(opts);
-			return booted.ok ? {
-				ok: true,
-				serial: booted.udid
-			} : booted;
-		},
-		install: ({ apkPath }) => core.installArtifact(apkPath),
-		launch: ({ packageName, metroPort, devClientScheme }) => core.launchApp({
-			appId: packageName,
-			metroPort,
-			devClientScheme
-		}),
-		createdSessionId: core.createdSessionId,
-		abandonCreatedSession: core.abandonCreatedSession,
-		webPreviewUrl: core.webPreviewUrl,
-		failureRemedy: core.failureRemedy
-	};
-}
-function endRecordedSession({ root, sessionId, easBin, lookupAgentDevice, ledgerRoot }) {
-	const agentDeviceBin = (lookupAgentDevice ?? defaultLookupAgentDevice)();
-	if (!easBin) return {
-		status: "failed",
-		reason: `No eas-cli to stop session ${sessionId} with; it keeps billing until its max duration. Run \`eas simulator:stop --id ${sessionId}\`.`
-	};
-	return teardownRemote({
-		root,
-		label: "",
-		backend: "eas",
-		easBin,
-		agentDeviceBin: agentDeviceBin ?? "",
-		existingDaemon: null,
-		easLedgerRoot: ledgerRoot
-	}, { sessionId });
-}
-function teardownRemote(ctx, { sessionId }) {
-	const profilePath = remoteProfilePath(ctx.root);
-	try {
-		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$1(ctx.easLedgerRoot);
-	const claimNeedsRemoval = !ledger.safe || ledger.claims.has(sessionId);
-	const removeClaim = () => {
-		try {
-			if ((ctx.removeEasSessionClaim ?? removeEasSessionClaim)(sessionId, ctx.easLedgerRoot) || !claimNeedsRemoval) return void 0;
-			return `EAS session ${sessionId} is stopped, but its ownership claim could not be removed. The claim and workspace record were kept for reconciliation. Re-run stop.`;
-		} catch (error) {
-			return `EAS session ${sessionId} is stopped, but its ownership claim could not be removed: ${describe(error)}. The claim and workspace record were kept for reconciliation. Re-run stop.`;
-		}
-	};
-	let sessionOutput;
-	try {
-		sessionOutput = getExecutor().runFile(ctx.easBin, getSessionArgs(sessionId), easBoundedExecOptions(ctx.root));
-	} catch (err) {
-		if (isDefinitiveMissingSessionError(err, sessionId)) return {
-			status: "torn-down",
-			reason: removeClaim()
-		};
-		return {
-			status: "failed",
-			reason: `Could not verify EAS session ${sessionId}: ${describe(err)}. The session record was kept for retry.`
-		};
-	}
-	const inspection = inspectSessionForTeardown(sessionOutput, sessionId);
-	if (inspection.action === "refused") return {
-		status: "failed",
-		reason: `${inspection.reason} The session record was kept for retry.`
-	};
-	if (inspection.action === "already-stopped") return {
-		status: "torn-down",
-		reason: removeClaim()
-	};
-	let stopOutput;
-	try {
-		stopOutput = getExecutor().runFile(ctx.easBin, stopSessionArgs(sessionId), easBoundedExecOptions(ctx.root));
-	} catch (err) {
-		return {
-			status: "failed",
-			reason: `eas simulator:stop ${sessionId} failed: ${describe(err)}. The session record was kept for retry.`
-		};
-	}
-	const verified = verifyStoppedSession(stopOutput, sessionId);
-	if (!verified.ok) return {
-		status: "failed",
-		reason: `${verified.reason} The session record was kept for retry.`
-	};
-	return {
-		status: "torn-down",
-		reason: removeClaim()
-	};
-}
-async function ensureMetroReachable({ ctx, metroPort, isExpo, tunnelMode = "auto", publicUrl = null, available = [], env = process.env, readTunnelRecord = readMetroTunnel, isTunnelAlive = pidExists, gateOrigin = gateMetroOrigin }) {
-	const { root } = ctx;
-	const platform = ctx.platform ?? "ios";
-	const publicMetroUrl = env["STIM_METRO_PUBLIC_URL"]?.trim() || publicUrl || null;
-	const recorded = readTunnelRecord(root);
-	const effectiveAvailable = recorded?.kind === "managed" && isTunnelAlive(recorded.pid) ? [recorded.provider, ...available.filter((provider) => provider !== recorded.provider)] : available;
-	const plan = planMetroReach({
-		mode: tunnelMode,
-		metroPort,
-		publicUrl: publicMetroUrl,
-		isExpo,
-		available: effectiveAvailable
-	});
-	if ("failed" in plan) return plan;
-	let resolvedUrl = null;
-	let gate = false;
-	if ("origin" in plan) {
-		resolvedUrl = plan.origin;
-		gate = plan.gate;
-	} else if ("expoTunnel" in plan) {
-		if (!recorded || recorded.kind !== "expo") return {
-			failed: "This workspace's Metro tunnels itself (metro.tunnel is expo, or auto on an Expo project), but no Expo tunnel URL is recorded.",
-			remedy: "Run `stim start --remote` so Expo can establish its own tunnel before a remote device connects."
-		};
-		resolvedUrl = recorded.url;
-		gate = true;
-	} else {
-		const port = Number(metroPort);
-		if (plan.start === "tailscale" && ctx.backend === "eas") return {
-			failed: "metro.tunnel is \"tailscale\", but an EAS Simulator is not on your tailnet and cannot reach it.",
-			remedy: "Use the proxy backend with a device on the same tailnet, or set metro.tunnel to \"auto\" or \"ngrok\".",
-			code: REMOTE_METRO_ERROR
-		};
-		const providerMatches = recorded?.kind === "managed" && recorded.provider === plan.start;
-		if (recorded && recorded.kind === "managed" && recorded.port === port && providerMatches && isTunnelAlive(recorded.pid)) resolvedUrl = recorded.url;
-		else return {
-			failed: `No live managed Metro tunnel is recorded for port ${port}.`,
-			remedy: "Run `stim start --remote`, then retry the device command."
-		};
-		gate = recorded.provider !== "tailscale";
-	}
-	if (gate && resolvedUrl) {
-		const logsDir = workspaceLogsDir$1(root);
-		const result = await gateOrigin({
-			origin: resolvedUrl,
-			metroPort,
-			platform,
-			entryPoint: bundleEntryPoint(root, isExpo),
-			readRecords: () => readMetroRecords(logsDir),
-			isProof: isBundleProof
-		});
-		if (result.failed) return {
-			failed: result.reason ?? "Metro gate failed.",
-			remedy: result.remedy ?? "",
-			code: REMOTE_METRO_WRONG
-		};
-	}
-	ctx.publicMetroUrl = resolvedUrl;
-	return { ok: true };
-}
-function bundleEntryPoint(root, isExpo) {
-	if (!isExpo) 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 { parseSessionListPage as C, gateMetroOrigin as D, readRemoteSimulatorArch as E, ownedSessionName as S, verifyStoppedSession as T, findOrphanedOwnedSessions as _, ensureMetroReachable as a, isDefinitiveMissingSessionError as b, remoteAndroidDeps as c, withRemoteSessionLock as d, withEasProjectLock as f, easCliUpgradeRemedy as g, easCliSupport as h, endRecordedSession as i, remoteIosDeps as l, MIN_EAS_CLI_SIMULATOR_VERSION as m, binOnPath as n, ensureRemoteBootOwned as o, MIN_EAS_CLI_DEVICE_VERSION as p, bundleEntryPoint as r, readInstalledEasCliVersion as s, REMOTE_SESSION_ERROR as t, resolveRemoteContext as u, getSessionArgs as v, stopSessionArgs as w, listOwnedSessionsArgs as x, inspectSessionForTeardown as y };