stim 1.15.0 → 1.17.0

package/dist/device-host-worker.mjs

@@ -1,26 +1,400 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { D as withConfigLock$1, _ as loadConfig$1, c as ensureConfig } from "./config-D0DbpZtM.mjs";
 import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { c as writeWorkspaceState, p as ensureWorkspaceStorage } from "./workspace-state-CL2V2Ons.mjs";
-import { A as listAvds, D as hostSystemImageArch, E as getAvdNameForSerial, O as listAdbDevices, R as ownedAvdName, W as pickDefaultSystemImage, a as androidDeviceAbi, b as createOwnedAvd, d as androidToolPath, j as listInstalledSystemImages, k as listAvdDeviceProfiles, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, v as bootAndroidEmulator } from "./android-Db2eEMaf.mjs";
-import { i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-BYuQafiA.mjs";
-import { C as resolveIosCreation, i as createOwnedIosSim, j as readHostMemoryPressure, n as bootIosSim, u as listAllIosSims } from "./ios-3CtCRhwr.mjs";
-import { a as requiredMacosRecord, r as macosProcess } from "./state-BxCgeTQu.mjs";
-import { _ as installIosApp, b as launchAndroidReleaseApp, h as installAndroidApp, s as androidAppProcess, v as iosAppProcess, x as launchIosApp } from "./app-install-CAAplXAt.mjs";
-import { h as findAapt } from "./support-CDQbDkL5.mjs";
-import { n as stopMacosAppHeld } from "./stop-Bvf1MflS.mjs";
-import { t as spawnEntry } from "./spawn-entry-DncpJvWL.mjs";
+import { c as writeWorkspaceState, u as ensureWorkspaceStorage } from "./workspace-state-DqcCbpE7.mjs";
+import { t as forgetCreatedDevice } from "./created-devices-CpvzBL25.mjs";
+import { A as listAvds, B as ownedAvdSystemImage, D as hostSystemImageArch, E as getAvdNameForSerial, J as resolveOwnedAvdSerial, O as listAdbDevices, R as ownedAvdName, W as pickDefaultSystemImage, _ as avdStorageRoots, a as androidDeviceAbi, b as createOwnedAvd, d as androidToolPath, f as assertOwnedAvdStopped, h as avdPathExists, j as listInstalledSystemImages, k as listAvdDeviceProfiles, q as resetAdoptedAvd, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, v as bootAndroidEmulator } from "./android-B_YNZy61.mjs";
+import { C as resolveIosCreation, D as uninstallIosApp, S as resetIosPrivacy, i as createOwnedIosSim, j as readHostMemoryPressure, m as listUserApps, n as bootIosSim, u as listAllIosSims, x as resetIosKeychain } from "./ios-DSfnPfse.mjs";
+import { g as teardownOwnedIosSim, m as teardownOwnedAvd } from "./ownership-BMLqyBgJ.mjs";
+import { a as requiredMacosRecord, r as macosProcess } from "./state-DyaNTgfR.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { n as parseLogStreamLine } from "./ios-Cr1h5gnO.mjs";
+import { n as parseLogcatLine, r as parsePidof, t as androidClockOffset } from "./android-DE4v59Mb.mjs";
+import { i as countLiveOwnedDevices } from "./device-capacity-D0GWHnTM.mjs";
+import { C as reverseMetroPorts, _ as installIosApp, b as launchAndroidReleaseApp, h as installAndroidApp, s as androidAppProcess, v as iosAppProcess, w as writeDebugHttpHost, x as launchIosApp, y as launchAndroidApp } from "./app-install-VPkI5WEg.mjs";
+import { h as findAapt } from "./support-F9-sr0Oi.mjs";
+import { n as stopMacosAppHeld } from "./stop-Cr1d8DSE.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, closeSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statfsSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, posix, relative, sep } from "node:path";
-import { configDir, withDirLock } from "@stim-cli/core";
-import { assertHostedDeviceLedger, hostedAppArea, hostedAppAttempt, hostedConsolePort, hostedMacosAppSlot, hostedMacosBundleId, isJsonObject, parseHostedOfferRequest, readHostedApp, readHostedDevice, readMacosRecord } from "@stim-cli/core/state";
+import { LOG_ROTATE_BYTES, configDir, withDirLock } from "@stim-cli/core";
+import { assertHostedDeviceLedger, hostedAppArea, hostedAppAttempt, hostedAppBlobs, hostedConsolePort, hostedMacosAppSlot, hostedMacosBundleId, hostedNativeLogsDir, isJsonObject, parseHostedOfferRequest, readHostedApp, readHostedAppMetadata, readHostedDevice, readHostedNativeLogsCheckpoint, readMacosRecord, readNdjsonGenerations } from "@stim-cli/core/state";
 import { availableParallelism, freemem, homedir, loadavg } from "node:os";
+//#region src/device-host/android-app.ts
+async function digest$1(path) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path)) hash.update(chunk);
+	return hash.digest("hex");
+}
+/** Installs only a verified single APK into the session's exact running ledger-owned AVD. */
+async function installHostedAndroidApp(home, session, attempt, device, metro) {
+	const record = readHostedApp(session, attempt, home);
+	const area = hostedAppArea(session, attempt, home);
+	if (record.state !== "installing") throw new Error("This app attempt has not been admitted for installation.");
+	const entry = record.files[0];
+	if (record.files.length !== 1 || !entry || entry.path !== "App.apk" || entry.kind !== "file") throw new Error("Hosted Android delivery requires a single file entry named App.apk.");
+	const manifest = join(hostedAppBlobs(session, home), record.manifest.sha256);
+	if (lstatSync(manifest).size !== record.manifest.size || await digest$1(manifest) !== record.manifest.sha256) throw new Error("The hosted APK manifest differs from its digest.");
+	const blob = join(hostedAppBlobs(session, home), entry.sha256);
+	const stat = lstatSync(blob);
+	if (!stat.isFile() || stat.size !== entry.size || await digest$1(blob) !== entry.sha256) throw new Error("APK content is incomplete or differs from its digest.");
+	const temporary = join(area, "App.apk.tmp");
+	const apk = join(area, "App.apk");
+	copyFileSync(blob, temporary);
+	renameSync(temporary, apk);
+	const tool = findAapt();
+	if (!tool) throw new Error("No installed Android build-tools can inspect the APK.");
+	const badging = getExecutor().runFile(tool.path, [
+		"dump",
+		"badging",
+		apk
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	});
+	const identity = /^package:\s+name='([^']+)'/m.exec(badging)?.[1];
+	const minimum = /^(?:sdkVersion|minSdkVersion):'(\d+)'\s*$/m.exec(badging)?.[1];
+	const api = /^system-images;android-(\d+);/.exec(device.systemImage)?.[1];
+	if (identity !== record.bundleId || !minimum || !api || Number(minimum) > Number(api)) throw new Error("The APK package identity or minimum SDK is incompatible with the hosted emulator.");
+	const nativeCode = /^native-code:\s*(.*)$/m.exec(badging)?.[1];
+	if (nativeCode !== void 0 && !nativeCode.split(/\s+/).includes(`'${device.architecture}'`)) throw new Error("The APK has no native library slice for the hosted emulator architecture.");
+	assertHostedAndroidTarget(home, device);
+	const sdkExecutor = hostedAndroidExecutor();
+	const installed = installAndroidApp({
+		serial: device.serial,
+		apkPath: apk,
+		packageName: record.bundleId
+	}, { exec: sdkExecutor });
+	if (!installed.ok) throw new Error(installed.reason ?? "Hosted APK installation was not established.");
+	assertHostedAndroidTarget(home, device);
+	if (record.mode === "development" && !metro) throw new Error("Hosted Android development launch requires its Metro bridge.");
+	const launched = record.mode === "development" && metro ? launchAndroidApp({
+		serial: device.serial,
+		packageName: record.bundleId,
+		metroPort: metro.devicePort,
+		bridgePort: metro.bridgePort,
+		physical: true,
+		devClientScheme: record.devClientScheme
+	}, { exec: sdkExecutor }) : launchAndroidReleaseApp({
+		serial: device.serial,
+		packageName: record.bundleId
+	}, { exec: sdkExecutor });
+	if (!launched.ok) throw new Error(launched.reason ?? "Hosted APK launch was not established.");
+	if (record.mode === "development") return "unverified";
+	for (let tries = 0; tries < 10; tries++) {
+		await new Promise((resolve) => setTimeout(resolve, 200));
+		if (androidAppProcess(device.serial, record.bundleId, { exec: sdkExecutor })) return true;
+	}
+	return "unverified";
+}
+function assertHostedAndroidSerial(home, device) {
+	assertHostedDeviceLedger(home, device.avdName, "android");
+	const current = readHostedDevice(home, "android");
+	if (current.avdName !== device.avdName || current.serial !== device.serial || current.systemImage !== device.systemImage || getAvdNameForSerial(device.serial, { timeoutMs: 2e3 }) !== device.avdName) throw new Error("The hosted Android device identity changed.");
+}
+function assertHostedAndroidTarget(home, device) {
+	assertHostedAndroidSerial(home, device);
+	if (androidDeviceAbi(device.serial) !== device.architecture) throw new Error("The hosted Android device identity or running ABI changed.");
+}
+function hostedAndroidExecutor() {
+	const executor = getExecutor();
+	const adb = androidToolPath("adb");
+	return {
+		...executor,
+		runFile: (file, args, options) => executor.runFile(file === "adb" ? adb : file, args, options)
+	};
+}
+function restoreHostedAndroidMetro(home, session, attempt, device, metro) {
+	const record = readHostedApp(session, attempt, home);
+	if (record.state !== "installed" || record.mode !== "development") throw new Error("Metro restore requires an installed development app.");
+	assertHostedAndroidTarget(home, device);
+	const exec = hostedAndroidExecutor();
+	const reversed = reverseMetroPorts({
+		serial: device.serial,
+		metroPort: metro.bridgePort,
+		devicePorts: [metro.devicePort]
+	}, { exec });
+	if (reversed.failed) throw new Error(reversed.reason);
+	assertHostedAndroidTarget(home, device);
+	writeDebugHttpHost({
+		serial: device.serial,
+		packageName: record.bundleId,
+		metroPort: metro.devicePort,
+		physical: true
+	}, { exec });
+}
+//#endregion
+//#region src/device-host/native-logs.ts
+function collectHostedNativeLogs({ home, platform, since, final, query, parse, tailOnly = false, deadline = Date.now() + 1e4, identity = {} }) {
+	const directory = hostedNativeLogsDir(home, platform);
+	const previous = readHostedNativeLogsCheckpoint(home, platform);
+	const beginning = Math.floor(since / 1e3) * 1e3;
+	let newest;
+	if (!previous) {
+		for (const entry of readNdjsonGenerations(join(directory, "device.ndjson"))) if (typeof entry.ts === "number" && (newest === void 0 || entry.ts > newest)) newest = entry.ts;
+	}
+	const checkpoint = previous?.until ?? Math.max(beginning, Math.floor((newest ?? beginning) / 1e3) * 1e3);
+	let from = Math.max(beginning, previous ? checkpoint - 5e3 : checkpoint);
+	const now = Math.floor(Date.now() / 1e3) * 1e3;
+	if (now < checkpoint) return false;
+	const backlogMs = Math.max(1e3, now - checkpoint);
+	let windowMs = !final && !tailOnly && previous?.windowMs ? Math.min(previous.windowMs * 2, backlogMs) : backlogMs;
+	let until = Math.min(now, checkpoint + windowMs);
+	let end = until === now ? until + 1e3 : until;
+	let output;
+	for (;;) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw new Error("Hosted native log query exceeded its collection budget.");
+		try {
+			output = query(from, end, Math.min(remaining, 4e3));
+			break;
+		} catch (error) {
+			const span = final || tailOnly ? until - from : until - checkpoint;
+			if (span <= 1e3) throw error;
+			windowMs = Math.max(1e3, Math.floor(span / 4 / 1e3) * 1e3);
+			if (final || tailOnly) from = Math.max(beginning, now - windowMs);
+			else until = Math.min(now, checkpoint + windowMs);
+			end = until === now ? until + 1e3 : until;
+			if (previous) {
+				mkdirSync(directory, {
+					recursive: true,
+					mode: 448
+				});
+				withDirLock(join(directory, "query.lock"), () => {
+					const temporary = join(directory, "checkpoint.json.tmp");
+					writeFileSync(temporary, JSON.stringify({
+						...previous,
+						until: checkpoint,
+						windowMs
+					}), { mode: 384 });
+					renameSync(temporary, join(directory, "checkpoint.json"));
+				});
+			}
+		}
+	}
+	const seen = /* @__PURE__ */ new Map();
+	for (const digest of previous?.boundary ?? []) seen.set(digest, (seen.get(digest) ?? 0) + 1);
+	const boundary = [];
+	const records = [];
+	if (from > checkpoint) records.push({
+		ts: from,
+		src: "device",
+		platform,
+		level: "warn",
+		msg: `Hosted ${platform === "ios" ? "iOS" : "Android"} native log gap: dropped interval [${new Date(checkpoint).toISOString()}, ${new Date(from).toISOString()}) to collect the tail within its budget.`
+	});
+	for (const line of output.split("\n")) {
+		const event = parse(line);
+		if (!event) continue;
+		const { record: parsed, digest } = event;
+		if (typeof parsed.ts !== "number" || parsed.ts < from || parsed.ts > end) continue;
+		if (parsed.ts >= until - 5e3) boundary.push(digest);
+		if (newest !== void 0 && parsed.ts <= newest) continue;
+		const count = seen.get(digest) ?? 0;
+		if (count) {
+			seen.set(digest, count - 1);
+			continue;
+		}
+		records.push({
+			...parsed,
+			platform
+		});
+	}
+	mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	withDirLock(join(directory, "query.lock"), () => {
+		const writer = createNdjsonWriter(join(directory, "device.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+		try {
+			for (const entry of records) if (!writer.write(entry)) throw new Error("Could not persist hosted native logs.");
+		} finally {
+			writer.close();
+		}
+		const temporary = join(directory, "checkpoint.json.tmp");
+		try {
+			writeFileSync(temporary, JSON.stringify({
+				until,
+				boundary,
+				...identity,
+				...until < now ? { windowMs } : {}
+			}), { mode: 384 });
+			renameSync(temporary, join(directory, "checkpoint.json"));
+		} finally {
+			rmSync(temporary, { force: true });
+		}
+	});
+	return until < now;
+}
+//#endregion
+//#region src/device-host/android-logs.ts
+/** Captures bounded logcat output from the installed app on this home's exact ledger-owned serial. */
+function collectHostedAndroidLogs(home, session, attempt, since, final = false) {
+	const deadline = Date.now() + 1e4;
+	const device = readHostedDevice(home, "android");
+	assertHostedAndroidSerial(home, device);
+	const app = readHostedAppMetadata(session, attempt, home);
+	if (app.state !== "installed") return false;
+	const exec = getExecutor();
+	const adb = androidToolPath("adb");
+	const clockOffsetMs = androidClockOffset(device.serial, { exec: {
+		...exec,
+		runFile: (file, args, options) => exec.runFile(file === "adb" ? adb : file, args, options)
+	} }) ?? 0;
+	const previous = readHostedNativeLogsCheckpoint(home, "android");
+	let current = null;
+	try {
+		current = parsePidof(exec.runFile(adb, [
+			"-s",
+			device.serial,
+			"shell",
+			"pidof",
+			app.bundleId
+		], {
+			timeoutMs: 2e3,
+			killSignal: "SIGKILL"
+		}));
+	} catch (error) {
+		const failure = error;
+		if (failure.status !== 1 || failure.signal != null || failure.stdout !== "" || failure.stderr !== "") throw error;
+	}
+	const prior = previous?.appAttempt === attempt ? previous.pid : void 0;
+	const pids = new Set([current, prior].filter((pid) => typeof pid === "number"));
+	if (!pids.size) return false;
+	return collectHostedNativeLogs({
+		home,
+		platform: "android",
+		since,
+		final,
+		deadline,
+		tailOnly: true,
+		identity: {
+			appAttempt: attempt,
+			pid: current ?? void 0
+		},
+		query: (from, _end, timeoutMs) => [...pids].map((pid) => {
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) throw new Error("Hosted native log query exceeded its collection budget.");
+			return exec.runFile(adb, [
+				"-s",
+				device.serial,
+				"logcat",
+				"-d",
+				"-v",
+				"epoch",
+				"-T",
+				((from - clockOffsetMs) / 1e3).toFixed(3),
+				"--pid",
+				String(pid)
+			], {
+				timeoutMs: Math.min(remaining, timeoutMs),
+				killSignal: "SIGKILL"
+			});
+		}).join("\n"),
+		parse: (line) => {
+			const record = parseLogcatLine(line, { clockOffsetMs });
+			if (!record || !pids.has(Number(/\((\d+)\)$/.exec(String(record.proc))?.[1]))) return null;
+			return {
+				record,
+				digest: createHash("sha256").update(line.trim()).digest("hex")
+			};
+		}
+	});
+}
+//#endregion
+//#region src/device-host/ios-logs.ts
+function logDate(ms) {
+	return new Date(ms).toISOString().replace("T", " ").replace(".000Z", "+0000");
+}
+/** Captures a bounded unified-log window only from this home's exact ledger-owned simulator. */
+function collectHostedIosLogs(home, session, attempt, since, final = false) {
+	const device = readHostedDevice(home);
+	assertHostedDeviceLedger(home, device.udid);
+	if (readHostedAppMetadata(session, attempt, home).state !== "installed") return false;
+	const deadline = Date.now() + 1e4;
+	const exec = getExecutor();
+	const executable = exec.runFile("/usr/libexec/PlistBuddy", [
+		"-c",
+		"Print :CFBundleExecutable",
+		join(hostedAppArea(session, attempt, home), "App.app", "Info.plist")
+	], {
+		timeoutMs: 2e3,
+		killSignal: "SIGKILL"
+	});
+	if (!executable || /["\\/\0\r\n]/.test(executable)) throw new Error("The app executable cannot form a log predicate.");
+	return collectHostedNativeLogs({
+		home,
+		platform: "ios",
+		deadline,
+		since,
+		final,
+		query: (from, end, timeoutMs) => exec.runFile("xcrun", [
+			"simctl",
+			"spawn",
+			device.udid,
+			"log",
+			"show",
+			"--style",
+			"ndjson",
+			"--predicate",
+			`processImagePath ENDSWITH "/App.app/${executable}"`,
+			"--info",
+			"--start",
+			logDate(from),
+			"--end",
+			logDate(end)
+		], {
+			timeoutMs,
+			killSignal: "SIGKILL"
+		}),
+		parse: (line) => {
+			const record = parseLogStreamLine(line);
+			if (!record) return null;
+			const entry = JSON.parse(line);
+			return {
+				record,
+				digest: createHash("sha256").update(JSON.stringify(Object.entries(entry).toSorted(([a], [b]) => a.localeCompare(b)))).digest("hex")
+			};
+		}
+	});
+}
+//#endregion
 //#region src/device-host/app.ts
 function inside(root, path) {
 	const diff = relative(root, path);
 	return diff !== "" && diff !== ".." && !diff.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(diff);
 }
-async function digest$1(path) {
+function removeHostedAppData(home, { keepBlobs = false } = {}) {
+	const area = realpathSync(join(home, ".."));
+	const assertInside = (path) => {
+		if (!inside(area, realpathSync(path))) throw new Error("Hosted app data resolves outside its private area.");
+	};
+	const remove = (path) => {
+		if (!lstatSync(path, { throwIfNoEntry: false })) return;
+		assertInside(path);
+		rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	};
+	assertInside(home);
+	const apps = join(area, "apps");
+	if (existsSync(apps)) {
+		assertInside(apps);
+		for (const attempt of readdirSync(apps)) {
+			const directory = join(apps, attempt);
+			if (!lstatSync(directory).isDirectory()) continue;
+			assertInside(directory);
+			remove(join(directory, "App.app"));
+			remove(join(directory, "App.apk"));
+			remove(join(directory, "App.apk.tmp"));
+			remove(join(directory, "blobs"));
+		}
+	}
+	if (!keepBlobs) remove(join(area, "blobs"));
+}
+async function digest(path) {
 	const hash = createHash("sha256");
 	for await (const chunk of createReadStream(path)) hash.update(chunk);
 	return hash.digest("hex");
@@ -42,19 +416,20 @@ function newer(value, supported) {
 async function materializeHostedApp(home, session, attempt) {
 	const record = readHostedApp(session, attempt, home);
 	const area = hostedAppArea(session, attempt, home);
+	const blobs = hostedAppBlobs(session, home);
 	const app = join(area, "App.app");
 	if (record.state !== "installing") throw new Error("This app attempt has not been admitted for installation.");
-	const manifest = join(area, "blobs", record.manifest.sha256);
-	if (lstatSync(manifest).size !== record.manifest.size || await digest$1(manifest) !== record.manifest.sha256) throw new Error("The hosted app manifest differs from its digest.");
+	const manifest = join(blobs, record.manifest.sha256);
+	if (lstatSync(manifest).size !== record.manifest.size || await digest(manifest) !== record.manifest.sha256) throw new Error("The hosted app manifest differs from its digest.");
 	rmSync(app, {
 		recursive: true,
 		force: true
 	});
 	mkdirSync(app, { mode: 448 });
 	for (const file of record.files) {
-		const blob = join(area, "blobs", file.sha256);
+		const blob = join(blobs, file.sha256);
 		const stat = lstatSync(blob);
-		if (!stat.isFile() || stat.size !== file.size || await digest$1(blob) !== file.sha256) throw new Error(`App content is incomplete or differs from its digest: ${file.path}`);
+		if (!stat.isFile() || stat.size !== file.size || await digest(blob) !== file.sha256) throw new Error(`App content is incomplete or differs from its digest: ${file.path}`);
 		if (file.kind === "link") continue;
 		const target = join(app, file.path);
 		mkdirSync(dirname(target), {
@@ -65,7 +440,7 @@ async function materializeHostedApp(home, session, attempt) {
 		chmodSync(target, file.kind === "exec" ? 493 : 420);
 	}
 	for (const file of record.files.filter((each) => each.kind === "link")) {
-		const bytes = readFileSync(join(area, "blobs", file.sha256));
+		const bytes = readFileSync(join(blobs, file.sha256));
 		const target = bytes.toString("utf8");
 		const destination = posix.normalize(posix.join(posix.dirname(file.path), target));
 		if (!target || !Buffer.from(target).equals(bytes) || /[\\\0\r\n]/.test(target) || posix.isAbsolute(target) || destination === "." || destination === ".." || destination.startsWith("../") || file.path.startsWith(`${destination}/`)) throw new Error(`The app link escapes its bundle or forms an ancestor cycle: ${file.path}`);
@@ -80,7 +455,7 @@ async function materializeHostedApp(home, session, attempt) {
 	for (const file of record.files) {
 		const path = realpathSync(join(app, file.path));
 		if (!inside(root, path)) throw new Error(`The app entry resolves outside its bundle: ${file.path}`);
-		if (file.kind !== "link" && await digest$1(path) !== file.sha256) throw new Error("App entries alias different content.");
+		if (file.kind !== "link" && await digest(path) !== file.sha256) throw new Error("App entries alias different content.");
 	}
 	return {
 		app,
@@ -201,8 +576,57 @@ async function runHostedDevice(mode, selectors, app) {
 			};
 		}
 		device = readHostedDevice(home);
-		assertHostedDeviceLedger(home, device.udid);
+		const ledger = assertHostedDeviceLedger(home, device.udid, "ios", { allowEmpty: mode === "stop" });
 		const current = inventory().find((sim) => sim.udid === device.udid);
+		if (mode === "inspect" || mode === "adopt") {
+			if (!current || !current.available || !current.name.startsWith("stim-") || current.name !== device.name || current.state !== "Shutdown") throw new Error("The parked hosted simulator is missing, renamed or not Shutdown.");
+			let choice;
+			try {
+				choice = selectHostedIosDevice(selectors);
+			} catch (error) {
+				if (mode === "inspect") return {
+					state: "incompatible",
+					device,
+					notice: error.message
+				};
+				throw error;
+			}
+			if (choice.deviceTypeId !== device.deviceTypeId || choice.runtimeId !== device.runtimeId || choice.architecture !== device.architecture) {
+				if (mode === "inspect") return {
+					state: "incompatible",
+					device
+				};
+				throw new Error("The parked hosted simulator does not match the requested selectors.");
+			}
+			if (mode === "inspect") return {
+				state: "compatible",
+				device
+			};
+			await bootIosSim(device.udid, { openViewer: false });
+			if (inventory().find((sim) => sim.udid === device.udid)?.state !== "Booted") throw new Error("Hosted simulator boot could not be verified.");
+			resetIosPrivacy(device.udid);
+			resetIosKeychain(device.udid);
+			for (const bundleId of listUserApps(device.udid)) uninstallIosApp(device.udid, bundleId);
+			withDirLock(join(home, "hosted-device.lock"), () => {
+				const temporary = join(home, "hosted-device.json.tmp");
+				writeFileSync(temporary, JSON.stringify(device), { mode: 384 });
+				renameSync(temporary, join(home, "hosted-device.json"));
+			});
+			removeHostedAppData(home, { keepBlobs: true });
+			return {
+				state: "ready",
+				device
+			};
+		}
+		if (mode === "park") {
+			const outcome = teardownOwnedIosSim(device.udid);
+			if (outcome.status !== "torn-down" || inventory().find((sim) => sim.udid === device.udid)?.state !== "Shutdown") throw new Error(outcome.reason ?? "Hosted simulator shutdown could not be verified.");
+			removeHostedAppData(home, { keepBlobs: true });
+			return {
+				state: "parked",
+				device
+			};
+		}
 		if (mode === "install") {
 			if (!app || current?.state !== "Booted") throw new Error("Hosted app installation requires its booted owned simulator.");
 			const launched = await installHostedApp(home, app.session, app.attempt, device, app.metroPort);
@@ -212,97 +636,33 @@ async function runHostedDevice(mode, selectors, app) {
 				launched
 			};
 		}
-		if (!current) return {
-			state: "stopped",
-			device
-		};
-		const outcome = teardownOwnedIosSim(device.udid);
+		if (ledger === "empty") {
+			if (current) throw new Error("The hosted simulator remains without ledger ownership; it was kept.");
+			removeHostedAppData(home);
+			return {
+				state: "stopped",
+				device
+			};
+		}
+		const outcome = teardownOwnedIosSim(device.udid, { del: true });
 		if (outcome.status !== "torn-down" && outcome.status !== "missing") throw new Error(outcome.reason ?? "Hosted simulator teardown was not established.");
 		const after = inventory().find((sim) => sim.udid === device.udid);
-		if (after && after.state !== "Shutdown") throw new Error("Hosted simulator shutdown could not be verified.");
+		if (after) throw new Error(`Hosted simulator ${device.udid} is still listed (${after.state}); deletion could not be verified. If its runtime is unavailable, delete it with xcrun simctl delete and stop the session again.`);
+		forgetCreatedDevice("ios", device.udid);
+		removeHostedAppData(home);
 		return {
 			state: "stopped",
 			device
 		};
 	} catch (error) {
 		return {
-			state: mode === "prepare" && !creationStarted && !device ? "stopped" : "unknown",
+			state: mode === "inspect" ? "unusable" : mode === "prepare" && !creationStarted && !device ? "stopped" : "unknown",
 			device,
 			notice: error.message
 		};
 	}
 }
 //#endregion
-//#region src/device-host/android-app.ts
-async function digest(path) {
-	const hash = createHash("sha256");
-	for await (const chunk of createReadStream(path)) hash.update(chunk);
-	return hash.digest("hex");
-}
-/** Installs only a verified single APK into the session's exact running ledger-owned AVD. */
-async function installHostedAndroidApp(home, session, attempt, device) {
-	const record = readHostedApp(session, attempt, home);
-	const area = hostedAppArea(session, attempt, home);
-	if (record.state !== "installing") throw new Error("This app attempt has not been admitted for installation.");
-	const entry = record.files[0];
-	if (record.files.length !== 1 || !entry || entry.path !== "App.apk" || entry.kind !== "file") throw new Error("Hosted Android delivery requires a single file entry named App.apk.");
-	const manifest = join(area, "blobs", record.manifest.sha256);
-	if (lstatSync(manifest).size !== record.manifest.size || await digest(manifest) !== record.manifest.sha256) throw new Error("The hosted APK manifest differs from its digest.");
-	const blob = join(area, "blobs", entry.sha256);
-	const stat = lstatSync(blob);
-	if (!stat.isFile() || stat.size !== entry.size || await digest(blob) !== entry.sha256) throw new Error("APK content is incomplete or differs from its digest.");
-	const temporary = join(area, "App.apk.tmp");
-	const apk = join(area, "App.apk");
-	copyFileSync(blob, temporary);
-	renameSync(temporary, apk);
-	const tool = findAapt();
-	if (!tool) throw new Error("No installed Android build-tools can inspect the APK.");
-	const badging = getExecutor().runFile(tool.path, [
-		"dump",
-		"badging",
-		apk
-	], {
-		timeoutMs: 1e4,
-		killSignal: "SIGKILL"
-	});
-	const identity = /^package:\s+name='([^']+)'/m.exec(badging)?.[1];
-	const minimum = /^(?:sdkVersion|minSdkVersion):'(\d+)'\s*$/m.exec(badging)?.[1];
-	const api = /^system-images;android-(\d+);/.exec(device.systemImage)?.[1];
-	if (identity !== record.bundleId || !minimum || !api || Number(minimum) > Number(api)) throw new Error("The APK package identity or minimum SDK is incompatible with the hosted emulator.");
-	const nativeCode = /^native-code:\s*(.*)$/m.exec(badging)?.[1];
-	if (nativeCode !== void 0 && !nativeCode.split(/\s+/).includes(`'${device.architecture}'`)) throw new Error("The APK has no native library slice for the hosted emulator architecture.");
-	const assertTarget = () => {
-		assertHostedDeviceLedger(home, device.avdName, "android");
-		const current = readHostedDevice(home, "android");
-		if (current.avdName !== device.avdName || current.serial !== device.serial || current.systemImage !== device.systemImage || getAvdNameForSerial(device.serial) !== device.avdName || androidDeviceAbi(device.serial) !== device.architecture) throw new Error("The hosted Android device identity or running ABI changed.");
-	};
-	assertTarget();
-	const executor = getExecutor();
-	const adb = androidToolPath("adb");
-	const sdkExecutor = {
-		...executor,
-		runFile: (file, args, options) => executor.runFile(file === "adb" ? adb : file, args, options)
-	};
-	const installed = installAndroidApp({
-		serial: device.serial,
-		apkPath: apk,
-		packageName: record.bundleId
-	}, { exec: sdkExecutor });
-	if (!installed.ok) throw new Error(installed.reason ?? "Hosted APK installation was not established.");
-	assertTarget();
-	const launched = launchAndroidReleaseApp({
-		serial: device.serial,
-		packageName: record.bundleId
-	}, { exec: sdkExecutor });
-	if (!launched.ok) throw new Error(launched.reason ?? "Hosted APK launch was not established.");
-	if (record.mode === "development") return "unverified";
-	for (let tries = 0; tries < 10; tries++) {
-		await new Promise((resolve) => setTimeout(resolve, 200));
-		if (androidAppProcess(device.serial, record.bundleId, { exec: sdkExecutor })) return true;
-	}
-	return "unverified";
-}
-//#endregion
 //#region src/device-host/android.ts
 function portIsOccupied(port) {
 	const devices = listAdbDevices({ timeoutMs: 5e3 });
@@ -327,10 +687,23 @@ async function runHostedAndroidDevice(mode, request, app) {
 	let device = null;
 	let creationStarted = false;
 	try {
-		if (mode === "install") {
-			if (!app) throw new Error("Hosted Android installation needs its admitted app attempt.");
+		if (mode === "install" || mode === "reverse") {
+			if (!app) throw new Error("Hosted Android native work needs its admitted app attempt.");
 			device = readHostedDevice(home, "android");
-			const launched = await installHostedAndroidApp(home, request.session, app.attempt, device);
+			if (!hostedConsolePort(request.consolePort) || device.consolePort !== request.consolePort) throw new Error("The hosted Android device identity differs from its session console port.");
+			const metro = app.metroPort && app.clientMetroPort ? {
+				bridgePort: app.metroPort,
+				devicePort: app.clientMetroPort
+			} : void 0;
+			if (mode === "reverse") {
+				if (!metro) throw new Error("Hosted Android Metro restore needs its bridge and device ports.");
+				restoreHostedAndroidMetro(home, request.session, app.attempt, device, metro);
+				return {
+					state: "ready",
+					device
+				};
+			}
+			const launched = await installHostedAndroidApp(home, request.session, app.attempt, device, metro);
 			return {
 				state: "installed",
 				device,
@@ -381,17 +754,88 @@ async function runHostedAndroidDevice(mode, request, app) {
 			};
 		}
 		device = readHostedDevice(home, "android");
-		assertHostedDeviceLedger(home, device.avdName, "android");
-		const outcome = teardownOwnedAvd(device.avdName);
-		if (outcome.status !== "torn-down" && outcome.status !== "missing") throw new Error(outcome.reason ?? "Hosted Android shutdown was not established.");
+		const ledger = assertHostedDeviceLedger(home, device.avdName, "android", { allowEmpty: mode === "stop" });
+		if (mode === "inspect" || mode === "adopt") {
+			if (device.avdName !== ownedAvdName(`hosted-${request.session}`) || !listAvds({ timeoutMs: 5e3 }).includes(device.avdName)) throw new Error("The parked hosted AVD is missing or names another session.");
+			if (!resolveOwnedAvdSerial(device.avdName, { timeoutMs: 5e3 }).notRunning) throw new Error("The parked hosted AVD is missing, not owned or running.");
+			assertOwnedAvdStopped(device.avdName);
+			if (getAvdNameForSerial(device.serial) === device.avdName) throw new Error("The parked hosted emulator is still running.");
+			if (ownedAvdSystemImage(device.avdName) !== device.systemImage) throw new Error("The parked hosted AVD system image no longer matches its device record.");
+			let choice;
+			try {
+				choice = selectHostedAndroidDevice(request);
+			} catch (error) {
+				if (mode === "inspect") return {
+					state: "incompatible",
+					device,
+					notice: error.message
+				};
+				throw error;
+			}
+			if (choice.systemImage !== device.systemImage || choice.deviceProfile !== device.deviceProfile || choice.architecture !== device.architecture) {
+				if (mode === "inspect") return {
+					state: "incompatible",
+					device
+				};
+				throw new Error("The parked hosted emulator does not match the requested selectors.");
+			}
+			if (mode === "inspect") return {
+				state: "compatible",
+				device
+			};
+			if (!hostedConsolePort(request.consolePort) || portIsOccupied(request.consolePort)) throw new Error("The selected Android console port is invalid or occupied.");
+			device = {
+				...device,
+				consolePort: request.consolePort,
+				serial: `emulator-${request.consolePort}`
+			};
+			withDirLock(join(home, "hosted-device.lock"), () => {
+				const temporary = join(home, "hosted-device.json.tmp");
+				writeFileSync(temporary, JSON.stringify(device), { mode: 384 });
+				renameSync(temporary, join(home, "hosted-device.json"));
+			});
+			bootAndroidEmulator(device.avdName, device.consolePort, {
+				openViewer: false,
+				logFile: join(home, "emulator.log")
+			});
+			if (!(await waitForBoot(device.serial, 24e4, { commandTimeoutMs: 5e3 })).ok || getAvdNameForSerial(device.serial) !== device.avdName || androidDeviceAbi(device.serial) !== device.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
+			await resetAdoptedAvd(device.avdName, device.serial, "");
+			removeHostedAppData(home, { keepBlobs: true });
+			return {
+				state: "ready",
+				device
+			};
+		}
+		if (mode === "park") {
+			const outcome = teardownOwnedAvd(device.avdName, {});
+			if (outcome.status !== "torn-down") throw new Error(outcome.reason ?? "Hosted Android shutdown was not established.");
+			assertOwnedAvdStopped(device.avdName);
+			if (getAvdNameForSerial(device.serial) === device.avdName) throw new Error("The hosted Android emulator is still running.");
+			removeHostedAppData(home, { keepBlobs: true });
+			return {
+				state: "parked",
+				device
+			};
+		}
+		if (ledger === "listed") {
+			withConfigLock$1(() => {
+				if (!loadConfig$1()) ensureConfig();
+			});
+			const outcome = teardownOwnedAvd(device.avdName, { del: true });
+			if (outcome.status !== "torn-down" && outcome.status !== "missing") throw new Error(outcome.reason ?? "Hosted Android deletion was not established.");
+		}
+		const name = device.avdName;
+		if (listAvds({ timeoutMs: 5e3 }).includes(name) || avdStorageRoots().some((root) => avdPathExists(join(root, `${name}.ini`)) || avdPathExists(join(root, `${name}.avd`)))) throw new Error("The hosted AVD or its data still exists; deletion could not be verified.");
 		if (getAvdNameForSerial(device.serial) === device.avdName) throw new Error("The hosted Android emulator is still running.");
+		if (ledger === "listed") forgetCreatedDevice("android", device.avdName);
+		removeHostedAppData(home);
 		return {
 			state: "stopped",
 			device
 		};
 	} catch (error) {
 		return {
-			state: mode === "prepare" && !creationStarted && !device ? "stopped" : "unknown",
+			state: mode === "inspect" ? "unusable" : mode === "prepare" && !creationStarted && !device ? "stopped" : "unknown",
 			device,
 			notice: error.message
 		};
@@ -504,6 +948,7 @@ async function runHostedMacosApp(mode, request, app) {
 					removeAppData(area, join(directory, "blobs"));
 				}
 			}
+			removeAppData(area, join(home, "..", "blobs"));
 			return {
 				state: "stopped",
 				device
@@ -667,7 +1112,7 @@ async function runHostedMacosApp(mode, request, app) {
 }
 //#endregion
 //#region src/device-host/offer.ts
-function inspectHostedDevice(request) {
+function inspectHostedDevice(request, options) {
 	const cpus = availableParallelism();
 	let workerDiskFreeBytes = null;
 	try {
@@ -679,7 +1124,8 @@ function inspectHostedDevice(request) {
 		loadPerCore: loadavg()[1] / cpus,
 		memoryFreeBytes: freemem(),
 		memoryPressure: readHostMemoryPressure(),
-		workerDiskFreeBytes
+		workerDiskFreeBytes,
+		...options ? { localDevices: countLiveOwnedDevices({}, options) } : {}
 	};
 	try {
 		if (process.platform !== "darwin") throw new Error("Hosted device sessions require a Mac.");
@@ -724,12 +1170,27 @@ async function main() {
 		"prepare",
 		"stop",
 		"install",
-		"offer"
+		"offer",
+		"count",
+		"logs",
+		"reverse",
+		"park",
+		"inspect",
+		"adopt"
 	].includes(String(input.mode))) throw new Error("Invalid hosted worker request.");
+	let exclude;
+	if (input.exclude !== void 0) {
+		if (!Array.isArray(input.exclude) || input.exclude.some((device) => !isJsonObject(device) || device.platform !== "ios" && device.platform !== "android" || device.key !== void 0 && typeof device.key !== "string")) throw new Error("Invalid hosted device exclusions.");
+		exclude = input.exclude;
+	}
+	if (input.mode === "count") {
+		process.stdout.write(`${JSON.stringify(countLiveOwnedDevices({}, { exclude }))}\n`);
+		return;
+	}
 	if (input.mode === "offer") {
 		const request = parseHostedOfferRequest(input);
 		if (!request) throw new Error("Invalid hosted offer selectors.");
-		process.stdout.write(`${JSON.stringify(inspectHostedDevice(request))}\n`);
+		process.stdout.write(`${JSON.stringify(inspectHostedDevice(request, exclude ? { exclude } : void 0))}\n`);
 		return;
 	}
 	if (process.platform !== "darwin") {
@@ -740,9 +1201,21 @@ async function main() {
 		})}\n`);
 		return;
 	}
-	if (input.mode === "install" && (typeof input.session !== "string" || !/^[a-f0-9-]{36}$/.test(input.session) || !hostedAppAttempt(input.attempt))) throw new Error("Invalid hosted app request.");
-	if (input.metroPort !== void 0 && (typeof input.metroPort !== "number" || !Number.isInteger(input.metroPort) || input.metroPort < 1 || input.metroPort > 65535)) throw new Error("Invalid hosted Metro port.");
+	if ((input.mode === "install" || input.mode === "logs" || input.mode === "reverse") && (typeof input.session !== "string" || !/^[a-f0-9-]{36}$/.test(input.session) || !hostedAppAttempt(input.attempt))) throw new Error("Invalid hosted app request.");
+	for (const port of [input.metroPort, input.clientMetroPort]) if (port !== void 0 && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) throw new Error("Invalid hosted Metro port.");
+	if (input.mode === "reverse" && input.platform !== "android") throw new Error("Metro reverse requires Android.");
+	if (input.platform === "macos" && [
+		"park",
+		"inspect",
+		"adopt"
+	].includes(String(input.mode))) throw new Error("Hosted parking requires iOS or Android.");
 	if (input.platform === "macos" && !hostedMacosAppSlot(input.appSlot)) throw new Error("Invalid hosted macOS app slot.");
+	if (input.mode === "logs") {
+		if (input.platform !== "ios" && input.platform !== "android" || !process.env.STIM_HOME || typeof input.since !== "number" || !Number.isFinite(input.since)) throw new Error("Invalid hosted native log request.");
+		const more = (input.platform === "android" ? collectHostedAndroidLogs : collectHostedIosLogs)(process.env.STIM_HOME, input.session, input.attempt, input.since, input.final === true);
+		process.stdout.write(`${JSON.stringify({ more })}\n`);
+		return;
+	}
 	const result = input.platform === "macos" ? await runHostedMacosApp(input.mode, {
 		session: typeof input.session === "string" ? input.session : "",
 		appSlot: input.appSlot
@@ -751,7 +1224,11 @@ async function main() {
 		consolePort: input.consolePort,
 		...typeof input.systemImage === "string" ? { systemImage: input.systemImage } : {},
 		...typeof input.deviceProfile === "string" ? { deviceProfile: input.deviceProfile } : {}
-	}, input.mode === "install" ? { attempt: input.attempt } : void 0) : await runHostedDevice(input.mode, {
+	}, input.mode === "install" || input.mode === "reverse" ? {
+		attempt: input.attempt,
+		metroPort: input.metroPort,
+		clientMetroPort: input.clientMetroPort
+	} : void 0) : await runHostedDevice(input.mode, {
 		...typeof input.deviceType === "string" ? { deviceType: input.deviceType } : {},
 		...typeof input.runtime === "string" ? { runtime: input.runtime } : {}
 	}, input.mode === "install" ? {