stim 1.16.0 → 1.17.0

package/dist/{guide-status-CjEZMAD4.mjs → guide-status-Du-ZQ3FD.mjs}

@@ -1,5 +1,5 @@
 import { E as upsertProject, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
-import { n as appProjectProblem } from "./project-Du91Ilvc.mjs";
+import { n as appProjectProblem } from "./project-D47Rh0ly.mjs";
 import { t as compareStimVersions } from "./stim-installations-QMEI32v1.mjs";
 import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/hosted-android-DwLS4Mse.mjs

@@ -0,0 +1,32 @@
+import { a as call, o as connectHost } from "./hosted-client-wk1W_CNW.mjs";
+import { i as requestHostedMetro } from "./metro-gateway-DmslUM30.mjs";
+import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-C9xJ9rpA.mjs";
+//#region src/device-host/hosted-android.ts
+async function prepareHostedAndroid(machine, selectors, recorded) {
+	return await prepareHostedNative(machine, selectors, recorded, "android");
+}
+async function placeHostedAndroid(target, options) {
+	return await placeHostedNative(target, {
+		...options,
+		platform: "android",
+		reserved: (placement) => options.reserved(placement)
+	});
+}
+async function stopHostedAndroid(root, slot) {
+	await stopHostedNative(root, slot, "android");
+}
+async function reopenHostedAndroidMetro(root, placement, clientMetroPort) {
+	const host = await connectHost(placement.machine, void 0, true);
+	try {
+		const gateway = await requestHostedMetro(root, placement.session, host.credential);
+		await call(host, "device-host.metro.open", {
+			session: placement.session,
+			clientMetroPort,
+			...gateway
+		});
+	} finally {
+		host.connection.close();
+	}
+}
+//#endregion
+export { stopHostedAndroid as i, prepareHostedAndroid as n, reopenHostedAndroidMetro as r, placeHostedAndroid as t };

package/dist/{hosted-client-a-WmqE2L.mjs → hosted-client-wk1W_CNW.mjs}

@@ -1,5 +1,4 @@
-import { t as BuildConnection, y as pinnedEndpoint$1 } from "./client-BTY686R6.mjs";
-import { t as configuredMachines } from "./machines-BIBUdhpj.mjs";
+import { b as pinnedEndpoint$1, r as BuildConnection, t as configuredMachines } from "./machines-C2XiNwh9.mjs";
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { join } from "node:path";
@@ -107,7 +106,7 @@ async function probeSession(placement, timeoutMs) {
 	let host;
 	try {
 		host = await connectHost(placement.machine, timeoutMs);
-		const session = await attach(host, placement.session, timeoutMs, placement.device === void 0 ? "macos" : "ios");
+		const session = await attach(host, placement.session, timeoutMs, placement.platform ?? (placement.device === void 0 ? "macos" : isJsonObject(placement.device) && "avdName" in placement.device ? "android" : "ios"));
 		if (session.state === "ready" || session.state === "stopped") return { state: session.state };
 		return {
 			state: "unknown",

package/dist/hosted-ios-aMo7Cljf.mjs

@@ -0,0 +1,15 @@
+import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-C9xJ9rpA.mjs";
+//#region src/device-host/hosted-ios.ts
+async function prepareHostedIos(machine, selectors, recorded) {
+	return await prepareHostedNative(machine, selectors, recorded, "ios");
+}
+async function placeHostedIos(target, options) {
+	return await placeHostedNative(target, {
+		...options,
+		platform: "ios",
+		reserved: (placement) => options.reserved(placement)
+	});
+}
+const stopHostedIos = stopHostedNative;
+//#endregion
+export { prepareHostedIos as n, stopHostedIos as r, placeHostedIos as t };

package/dist/{hosted-logs-D5g041Q3.mjs → hosted-logs-DqYmWtXc.mjs}

@@ -1,11 +1,11 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { L as deviceSlotFileKey, W as validateDeviceSlot } from "./config-D0DbpZtM.mjs";
-import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
-import { v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
-import { t as macosDir } from "./state-3DwSQIBK.mjs";
+import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
+import { v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
+import { t as macosDir } from "./state-DyaNTgfR.mjs";
 import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
-import { v as parseMachine$1 } from "./client-BTY686R6.mjs";
-import { a as call } from "./hosted-client-a-WmqE2L.mjs";
+import { y as parseMachine$1 } from "./machines-C2XiNwh9.mjs";
+import { a as call } from "./hosted-client-wk1W_CNW.mjs";
 import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { LOG_ROTATE_BYTES, withDirLock } from "@stim-cli/core";
@@ -14,7 +14,7 @@ import { isJsonObject, parseHostedAgentGrant, parseHostedLogsCursor } from "@sti
 function agentAccess(file, credential, grant, note, platform = "macos") {
 	const parsed = grant === void 0 ? null : parseHostedAgentGrant(grant);
 	if (grant !== void 0 && !parsed) note(`${credential.machine} offered agent control this Stim does not support.`);
-	if (!parsed || parsed.driver === "none" || parsed.lease.backend === "ios-instance" !== (platform === "ios")) {
+	if (!parsed || parsed.driver === "none" || parsed.lease.backend !== (platform === "macos" ? void 0 : `${platform}-instance`)) {
 		rmSync(file, { force: true });
 		return {
 			driver: "none",
@@ -29,7 +29,7 @@ function agentAccess(file, credential, grant, note, platform = "macos") {
 		sessionIsolation: "tenant",
 		runId: parsed.lease.runId,
 		...platform === "macos" ? { leaseId: parsed.scope } : {},
-		leaseBackend: platform === "ios" ? "ios-instance" : "macos-app",
+		leaseBackend: platform === "macos" ? "macos-app" : `${platform}-instance`,
 		leaseProvider: "proxy",
 		clientId: parsed.lease.clientId,
 		deviceKey: parsed.lease.deviceKey,
@@ -108,9 +108,9 @@ const MACOS = {
 	platform: "macos",
 	slot: "default"
 };
-const logsStateDir = (root, target) => target.platform === "macos" ? macosDir(root) : join(workspaceDir(root), "ios", validateDeviceSlot(target.slot));
+const logsStateDir = (root, target) => target.platform === "macos" ? macosDir(root) : join(workspaceDir(root), target.platform, validateDeviceSlot(target.slot));
 const cursorFile = (root, target) => join(logsStateDir(root, target), "host-logs-cursor.json");
-const hostLogFile = (root, target) => join(workspaceLogsDir$1(root), `${target.platform === "macos" ? "macos" : deviceSlotFileKey("ios", target.slot)}-host.ndjson`);
+const hostLogFile = (root, target) => join(workspaceLogsDir$1(root), `${target.platform === "macos" ? "macos" : deviceSlotFileKey(target.platform, target.slot)}-host.ndjson`);
 function readCursor(root, session, target) {
 	try {
 		const stored = JSON.parse(readFileSync(cursorFile(root, target), "utf8"));
@@ -126,10 +126,10 @@ function commitPage(root, session, before, records, cursor, target) {
 		if (records.length) {
 			const writer = createNdjsonWriter(hostLogFile(root, target), { maxBytes: LOG_ROTATE_BYTES });
 			try {
-				for (const record of records) writer.write(target.platform === "ios" ? {
+				for (const record of records) writer.write(target.platform !== "macos" ? {
 					...record,
 					src: "device",
-					platform: "ios",
+					platform: target.platform,
 					slot: target.slot,
 					event: "hosted_native_log"
 				} : record);
@@ -174,14 +174,14 @@ async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPag
 		}
 		checkpoint = nextCheckpoint;
 	}
-	if (target.platform === "ios") throw new Error(final ? "Final native log copy reached its time or page bound; the host keeps collected logs after stop." : "Hosted native logs still have unread pages; run stim logs again.");
+	if (target.platform !== "macos") throw new Error(final ? "Final native log copy reached its time or page bound; the host keeps collected logs after stop." : "Hosted native logs still have unread pages; run stim logs again.");
 }
-async function pullHostedIosLogs(root, slot, placement, host, final = false) {
-	if (!host.connection.supports("hosted-ios-data")) throw new Error(`${host.machine} needs a newer stim-server to collect hosted iOS native logs.`);
+async function pullHostedNativeLogs(root, slot, placement, host, final = false, platform = "ios") {
+	if (!host.connection.supports(platform === "ios" ? "hosted-ios-data" : "hosted-android-data")) throw new Error(`${host.machine} needs a newer stim-server to collect hosted ${platform === "ios" ? "iOS" : "Android"} native logs.`);
 	await pullHostedMacosLogs(root, placement, host, {
-		platform: "ios",
+		platform,
 		slot
 	}, final ? 1024 : MAX_PAGES, final);
 }
 //#endregion
-export { agentAccess as i, pullHostedMacosLogs as n, closeAgentConnection as r, pullHostedIosLogs as t };
+export { agentAccess as i, pullHostedNativeLogs as n, closeAgentConnection as r, pullHostedMacosLogs as t };

package/dist/{hosted-macos-BSZyIb3y.mjs → hosted-macos-dlHXEeF5.mjs}

@@ -1,7 +1,7 @@
-import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
-import { t as macosDir } from "./state-3DwSQIBK.mjs";
-import { a as call, c as hostedSession, d as sha256, f as sleep, i as bundleManifest, m as upload, n as SESSION_TIMEOUT_MS, o as connectHost, p as unknownSession, r as attach, s as heldNoLonger, t as INSTALL_TIMEOUT_MS, u as settle } from "./hosted-client-a-WmqE2L.mjs";
-import { i as agentAccess, n as pullHostedMacosLogs, r as closeAgentConnection } from "./hosted-logs-D5g041Q3.mjs";
+import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
+import { t as macosDir } from "./state-DyaNTgfR.mjs";
+import { a as call, c as hostedSession, d as sha256, f as sleep, i as bundleManifest, m as upload, n as SESSION_TIMEOUT_MS, o as connectHost, p as unknownSession, r as attach, s as heldNoLonger, t as INSTALL_TIMEOUT_MS, u as settle } from "./hosted-client-wk1W_CNW.mjs";
+import { i as agentAccess, r as closeAgentConnection, t as pullHostedMacosLogs } from "./hosted-logs-DqYmWtXc.mjs";
 import { randomUUID } from "node:crypto";
 import { rmSync } from "node:fs";
 import { join } from "node:path";

package/dist/{hosted-ios-CIWelIqf.mjs → hosted-native-C9xJ9rpA.mjs}

@@ -1,50 +1,57 @@
-import { r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
-import { a as call, c as hostedSession, d as sha256, f as sleep, i as bundleManifest, m as upload, n as SESSION_TIMEOUT_MS, o as connectHost, p as unknownSession, r as attach, s as heldNoLonger, t as INSTALL_TIMEOUT_MS, u as settle } from "./hosted-client-a-WmqE2L.mjs";
-import { i as requireHostedMetro, n as closeHostedMetro, r as requestHostedMetro } from "./metro-gateway-BJ-rxQAB.mjs";
-import { i as agentAccess, r as closeAgentConnection, t as pullHostedIosLogs } from "./hosted-logs-D5g041Q3.mjs";
-import { n as writeHostedIos } from "./ios-state-DS5UpYTH.mjs";
+import { r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
+import { a as call, c as hostedSession, d as sha256, f as sleep, i as bundleManifest, m as upload, n as SESSION_TIMEOUT_MS, o as connectHost, p as unknownSession, r as attach, s as heldNoLonger, t as INSTALL_TIMEOUT_MS, u as settle } from "./hosted-client-wk1W_CNW.mjs";
+import { a as requireHostedMetro, i as requestHostedMetro, n as closeHostedMetro } from "./metro-gateway-DmslUM30.mjs";
+import { i as agentAccess, n as pullHostedNativeLogs, r as closeAgentConnection } from "./hosted-logs-DqYmWtXc.mjs";
+import { s as writeHostedNative } from "./ios-state-8L3lgum6.mjs";
 import { randomUUID } from "node:crypto";
-import { rmSync } from "node:fs";
+import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { hostedIosRecords, isJsonObject, parseHostedChoice, parseHostedDevice, parseHostedIosPlacement, unreadableHostedIos } from "@stim-cli/core/state";
-//#region src/device-host/hosted-ios.ts
+import { hostedNativeRecords, isJsonObject, parseHostedAndroidDevice, parseHostedChoice, parseHostedDevice, parseHostedNativeOffer, parseHostedNativePlacement, unreadableHostedNative } from "@stim-cli/core/state";
+//#region src/device-host/hosted-native.ts
 function hostingRefusal(machine, error) {
 	return Object.assign(/* @__PURE__ */ new Error(`${machine}: ${error instanceof Error ? error.message : String(error)}`), {
 		code: "STIM_HOSTING_REFUSED",
 		...error instanceof Error && "remedy" in error ? { remedy: error.remedy } : {}
 	});
 }
+const androidAgentRemoteConfig = (root, slot) => join(workspaceDir(root), "hosted-android", slot, "agent-device-remote.json");
 const iosAgentRemoteConfig = (root, slot) => join(workspaceDir(root), "hosted-ios", slot, "agent-device-remote.json");
-async function prepareHostedIos(machine, selectors, recorded) {
+async function prepareHostedNative(machine, selectors, recorded, platform = "ios", resumeOnly = false) {
 	let host;
 	try {
 		host = await connectHost(machine, void 0, true);
 		if (recorded) {
 			let session = null;
 			try {
-				session = await settle(host, await attach(host, recorded.session, void 0, "ios"), ["preparing", "stopping"], SESSION_TIMEOUT_MS, "ios");
+				session = await settle(host, await attach(host, recorded.session, void 0, platform), ["preparing", "stopping"], SESSION_TIMEOUT_MS, platform);
 			} catch (error) {
 				if (!heldNoLonger(error)) throw error;
 			}
 			if (session && session.state !== "stopped") {
 				if (session.state !== "ready") throw unknownSession(host, session);
-				const device = parseHostedDevice(session.device);
+				const device = platform === "ios" ? parseHostedDevice(session.device) : parseHostedAndroidDevice(session.device);
 				if (!device) throw new Error("The ready session has no simulator identity.");
-				if (selectors.deviceType && selectors.deviceType !== device.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== device.runtime.replace(/^iOS /, "")) throw new Error(`This session uses ${device.deviceType} (iOS ${device.runtime.replace(/^iOS /, "")}); run stim stop first to change it.`);
+				if ("udid" in device ? selectors.deviceType && selectors.deviceType !== device.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== device.runtime.replace(/^iOS /, "") : selectors.systemImage && selectors.systemImage !== device.systemImage || selectors.deviceProfile && selectors.deviceProfile !== device.deviceProfile) throw new Error("udid" in device ? `This session uses ${device.deviceType} (iOS ${device.runtime.replace(/^iOS /, "")}); run stim stop first to change it.` : `This session uses ${device.deviceProfile} (${device.systemImage}); run stim stop first to change it.`);
 				return {
 					host,
 					choice: device,
-					session
+					session,
+					selection: {
+						selected: recorded.selected,
+						...recorded.reason !== void 0 ? { reason: recorded.reason } : {}
+					}
 				};
 			}
 		}
+		if (resumeOnly) return null;
 		const offer = await call(host, "device-host.offer", {
-			platform: "ios",
+			platform,
 			...selectors
 		}, 3e3);
-		const choice = offer.platform === "ios" ? parseHostedChoice(offer.choice) : null;
+		const parsedOffer = parseHostedNativeOffer(offer);
+		const choice = platform === "ios" ? offer.platform === "ios" ? parseHostedChoice(offer.choice) : null : parsedOffer?.platform === "android" ? parsedOffer.choice : null;
 		if (typeof offer.declined === "string") throw new Error(offer.declined);
-		if (!choice) throw new Error("No compatible installed iOS simulator runtime was offered.");
+		if (!choice) throw new Error(platform === "ios" ? "No compatible installed iOS simulator runtime was offered." : "No compatible installed Android emulator image was offered.");
 		if (!isJsonObject(offer.capacity) || offer.capacity.available === 0) throw new Error("No hosted device capacity is available.");
 		if (!isJsonObject(offer.resources) || offer.resources.memoryPressure !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
 		return {
@@ -59,35 +66,48 @@ async function prepareHostedIos(machine, selectors, recorded) {
 		host?.connection.close();
 	}
 }
-async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, selectors, release, devClientScheme, reserved, note, metro = requestHostedMetro }) {
+async function reserveHostedNative(host, target, params, platform) {
+	try {
+		return hostedSession(host, await call(host, "device-host.reserve", params), platform);
+	} catch (error) {
+		if (target.selection?.selected !== "auto") throw error;
+		throw Object.assign(/* @__PURE__ */ new Error(`${error instanceof Error ? error.message : String(error)} Retry stim ${platform} --remote auto; the build already targets ${host.machine}'s architecture.`), { remedy: `Retry stim ${platform} --remote auto.` });
+	}
+}
+async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId, selectors, release, devClientScheme, reserved, note, metro = requestHostedMetro, metroPort, platform = "ios" }) {
 	let host = target.host;
 	try {
 		if (!release && metro === requestHostedMetro) requireHostedMetro(root);
 		host = await connectHost(host.machine, void 0, true);
 		target.host = host;
-		let session = (target.session ? await attach(host, target.session.id, void 0, "ios") : null) ?? hostedSession(host, await call(host, "device-host.reserve", {
-			platform: "ios",
+		let session = (target.session ? await attach(host, target.session.id, void 0, platform) : null) ?? await reserveHostedNative(host, target, {
+			platform,
 			workspace: root,
 			slot,
 			attempt: randomUUID(),
-			...selectors
-		}), "ios");
+			...selectors,
+			...platform === "android" && "systemImage" in target.choice ? {
+				systemImage: target.choice.systemImage,
+				deviceProfile: target.choice.deviceProfile
+			} : {}
+		}, platform);
 		let placement = {
 			machine: host.machine,
-			selected: host.machine,
+			selected: target.selection?.selected ?? host.machine,
+			...target.selection ? { reason: target.selection.reason } : {},
 			session: session.id,
 			appAttempt: randomUUID(),
-			device: parseHostedDevice(session.device),
+			device: platform === "ios" ? parseHostedDevice(session.device) : parseHostedAndroidDevice(session.device),
 			agent: {
 				driver: "none",
 				setting: "hosting.agentDriver"
 			}
 		};
 		reserved(placement);
-		session = await settle(host, session, ["preparing"], SESSION_TIMEOUT_MS, "ios");
+		session = await settle(host, session, ["preparing"], SESSION_TIMEOUT_MS, platform);
 		if (session.state !== "ready") throw unknownSession(host, session);
-		const device = parseHostedDevice(session.device);
-		if (!device || device.architecture !== target.choice.architecture) throw new Error("The reserved simulator does not match the offered architecture.");
+		const device = platform === "ios" ? parseHostedDevice(session.device) : parseHostedAndroidDevice(session.device);
+		if (!device || device.architecture !== target.choice.architecture || "avdName" in device && "systemImage" in target.choice && (device.systemImage !== target.choice.systemImage || device.deviceProfile !== target.choice.deviceProfile)) throw new Error(platform === "ios" ? "The reserved simulator does not match the offered architecture." : "The reserved emulator does not match the offered architecture or selectors.");
 		placement = {
 			...placement,
 			device
@@ -97,13 +117,26 @@ async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, s
 			const gateway = await metro(root, session.id, host.credential);
 			await call(host, "device-host.metro.open", {
 				session: session.id,
-				...gateway
+				...gateway,
+				...platform === "android" ? { clientMetroPort: metroPort } : {}
 			});
 		} else {
 			await call(host, "device-host.metro.close", { session: session.id });
 			await closeHostedMetro(root, session.id);
 		}
-		const { files, content } = bundleManifest(bundle);
+		const { files, content } = platform === "ios" ? bundleManifest(bundle) : (() => {
+			const apk = readFileSync(bundle);
+			const digest = sha256(apk);
+			return {
+				files: [{
+					path: "App.apk",
+					kind: "file",
+					size: apk.length,
+					sha256: digest
+				}],
+				content: /* @__PURE__ */ new Map([[digest, () => apk]])
+			};
+		})();
 		const manifest = Buffer.from(JSON.stringify(files));
 		content.set(sha256(manifest), () => manifest);
 		const ids = {
@@ -120,11 +153,11 @@ async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, s
 				size: manifest.length
 			}
 		};
-		note(`Delivering ${files.length} files to ${host.machine} (${device.runtime}, ${device.architecture})`);
+		note(`Delivering ${files.length} files to ${host.machine} (${"runtime" in device ? device.runtime : device.systemImage}, ${device.architecture})`);
 		await upload(host, ids, (await call(host, "device-host.app.offer", offer)).missing, content);
 		let missing = (await call(host, "device-host.app.offer", offer)).missing;
 		if (handoff && handoff.nodeId === host.credential.nodeId && Array.isArray(missing) && missing.length) {
-			if (!host.connection.supports("hosted-ios-data")) note(`${host.machine} needs a newer stim-server for iOS build handoff; uploading the app instead`);
+			if (!host.connection.supports(platform === "android" ? "hosted-android-data" : "hosted-ios-data")) note(`${host.machine} needs a newer stim-server for ${platform === "ios" ? "iOS" : "Android"} build handoff; uploading the app instead`);
 			else try {
 				const taken = await call(host, "device-host.app.handoff", {
 					...ids,
@@ -160,7 +193,7 @@ async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, s
 		if (typeof delivery.notice === "string") note(delivery.notice);
 		placement = {
 			...placement,
-			agent: agentAccess(iosAgentRemoteConfig(root, slot), host.credential, host.connection.supports("hosted-ios-agent") ? delivery.agent : void 0, note, "ios")
+			agent: agentAccess(platform === "ios" ? iosAgentRemoteConfig(root, slot) : androidAgentRemoteConfig(root, slot), host.credential, host.connection.supports(platform === "ios" ? "hosted-ios-agent" : "hosted-android-agent") ? delivery.agent : void 0, note, platform)
 		};
 		return {
 			placement,
@@ -168,15 +201,17 @@ async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, s
 		};
 	} catch (error) {
 		throw hostingRefusal(host.machine, error);
+	} finally {
+		if (platform === "android") host.connection.close();
 	}
 }
-async function stopHostedIos(root, slot) {
+async function stopHostedNative(root, slot, platform = "ios") {
 	const failures = [];
-	for (const [name, record] of Object.entries(hostedIosRecords(readWorkspaceState$1(root)))) {
+	for (const [name, record] of Object.entries(hostedNativeRecords(readWorkspaceState$1(root), platform))) {
 		if (slot !== void 0 && name !== slot) continue;
-		const placement = parseHostedIosPlacement(record);
+		const placement = parseHostedNativePlacement(record, platform);
 		if (!placement) {
-			failures.push(unreadableHostedIos(name));
+			failures.push(unreadableHostedNative(name, platform));
 			continue;
 		}
 		if (placement.agent.driver === "agent-device") closeAgentConnection(placement.agent.remoteConfig);
@@ -184,14 +219,14 @@ async function stopHostedIos(root, slot) {
 		try {
 			host = await connectHost(placement.machine);
 			try {
-				await pullHostedIosLogs(root, name, placement, host, true);
+				await pullHostedNativeLogs(root, name, placement, host, true, platform);
 			} catch (error) {
 				process.stderr.write(`Could not copy final native logs from ${placement.machine}: ${error.message}\n`);
 			}
-			const stopped = await settle(host, hostedSession(host, await call(host, "device-host.stop", { session: placement.session }), "ios"), ["stopping"], SESSION_TIMEOUT_MS, "ios");
+			const stopped = await settle(host, hostedSession(host, await call(host, "device-host.stop", { session: placement.session }), platform), ["stopping"], SESSION_TIMEOUT_MS, platform);
 			if (stopped.state !== "stopped") throw unknownSession(host, stopped);
 			try {
-				await pullHostedIosLogs(root, name, placement, host, true);
+				await pullHostedNativeLogs(root, name, placement, host, true, platform);
 			} catch (error) {
 				process.stderr.write(`Could not copy the host's final native logs from ${placement.machine}: ${error.message}\n`);
 			}
@@ -200,7 +235,7 @@ async function stopHostedIos(root, slot) {
 			const hostCode = error instanceof Error && "hostCode" in error ? error.hostCode : code;
 			if (hostCode !== "unknown-session" && hostCode !== "forbidden") {
 				const remedy = code === "closed" || code === "timeout" ? "rerun stim stop when that machine answers." : code === "STIM_BAD_ARG" || code === "STIM_HOSTING_REFUSED" ? "run stim doctor, restore hosting access, then rerun stim stop." : "run stim stop to reconcile the session.";
-				failures.push(`Could not stop the iOS simulator on ${placement.machine}: ${(error instanceof Error ? error.message : String(error)).replace(/\.+$/, "")}. The placement is kept; ${remedy}`);
+				failures.push(`Could not stop the ${platform === "ios" ? "iOS simulator" : "Android emulator"} on ${placement.machine}: ${(error instanceof Error ? error.message : String(error)).replace(/\.+$/, "")}. The placement is kept; ${remedy}`);
 				continue;
 			}
 		} finally {
@@ -208,8 +243,8 @@ async function stopHostedIos(root, slot) {
 		}
 		try {
 			await closeHostedMetro(root, placement.session);
-			rmSync(iosAgentRemoteConfig(root, name), { force: true });
-			writeHostedIos(root, name, null);
+			rmSync(platform === "ios" ? iosAgentRemoteConfig(root, name) : androidAgentRemoteConfig(root, name), { force: true });
+			writeHostedNative(root, name, null, platform);
 		} catch (error) {
 			failures.push(`${placement.machine}: ${error.message}. The placement is kept; rerun stim stop.`);
 		}
@@ -217,4 +252,4 @@ async function stopHostedIos(root, slot) {
 	if (failures.length) throw new Error(failures.join("\n"));
 }
 //#endregion
-export { prepareHostedIos as n, stopHostedIos as r, placeHostedIos as t };
+export { prepareHostedNative as n, stopHostedNative as r, placeHostedNative as t };