stim 1.14.0 → 1.16.0

package/dist/device-host-worker.mjs

@@ -0,0 +1,964 @@
+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, u as ensureWorkspaceStorage } from "./workspace-state-B8-aJ1_5.mjs";
+import { t as forgetCreatedDevice } from "./created-devices-D5owjN4C.mjs";
+import { A as listAvds, D as hostSystemImageArch, E as getAvdNameForSerial, O as listAdbDevices, R as ownedAvdName, W as pickDefaultSystemImage, _ as avdStorageRoots, a as androidDeviceAbi, b as createOwnedAvd, d as androidToolPath, h as avdPathExists, j as listInstalledSystemImages, k as listAvdDeviceProfiles, t as DEFAULT_AVD_DEVICE_PROFILE, tt as waitForBoot, v as bootAndroidEmulator } from "./android-B_NumVyQ.mjs";
+import { C as resolveIosCreation, i as createOwnedIosSim, j as readHostMemoryPressure, n as bootIosSim, u as listAllIosSims } from "./ios-BaInn3sW.mjs";
+import { i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-CL6vDs2Y.mjs";
+import { a as requiredMacosRecord, r as macosProcess } from "./state-3DwSQIBK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { n as parseLogStreamLine } from "./ios-Cr1h5gnO.mjs";
+import { _ as installIosApp, b as launchAndroidReleaseApp, h as installAndroidApp, s as androidAppProcess, v as iosAppProcess, x as launchIosApp } from "./app-install-CKWdbXIX.mjs";
+import { h as findAapt } from "./support-CAP8qDUF.mjs";
+import { n as stopMacosAppHeld } from "./stop-B0Yxtmiy.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 { LOG_ROTATE_BYTES, configDir, withDirLock } from "@stim-cli/core";
+import { assertHostedDeviceLedger, hostedAppArea, hostedAppAttempt, hostedAppBlobs, hostedConsolePort, hostedIosLogsDir, hostedMacosAppSlot, hostedMacosBundleId, isJsonObject, parseHostedOfferRequest, readHostedApp, readHostedAppMetadata, readHostedDevice, readHostedIosLogsCheckpoint, readMacosRecord, readNdjsonGenerations } from "@stim-cli/core/state";
+import { availableParallelism, freemem, homedir, loadavg } from "node:os";
+//#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 directory = hostedIosLogsDir(home);
+	const previous = readHostedIosLogsCheckpoint(home);
+	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 && previous?.windowMs ? Math.min(previous.windowMs * 2, backlogMs) : backlogMs;
+	let until = Math.min(now, checkpoint + windowMs);
+	let end = until === now ? until + 1e3 : until;
+	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.");
+	let output;
+	for (;;) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw new Error("Hosted native log query exceeded its collection budget.");
+		try {
+			output = 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: Math.min(remaining, 4e3),
+				killSignal: "SIGKILL"
+			});
+			break;
+		} catch (error) {
+			const span = final ? until - from : until - checkpoint;
+			if (span <= 1e3) throw error;
+			windowMs = Math.max(1e3, Math.floor(span / 4 / 1e3) * 1e3);
+			if (final) 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({
+						until: checkpoint,
+						boundary: previous.boundary,
+						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 (final && from > checkpoint) records.push({
+		ts: from,
+		src: "device",
+		platform: "ios",
+		level: "warn",
+		msg: `Hosted iOS native log gap: dropped interval [${new Date(checkpoint).toISOString()}, ${new Date(from).toISOString()}) to collect the final tail within its budget.`
+	});
+	for (const line of output.split("\n")) {
+		const parsed = parseLogStreamLine(line);
+		if (!parsed || typeof parsed.ts !== "number" || parsed.ts < from || parsed.ts > end) continue;
+		const entry = JSON.parse(line);
+		const digest = createHash("sha256").update(JSON.stringify(Object.entries(entry).toSorted(([a], [b]) => a.localeCompare(b)))).digest("hex");
+		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: "ios"
+		});
+	}
+	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 iOS native logs.");
+		} finally {
+			writer.close();
+		}
+		const temporary = join(directory, "checkpoint.json.tmp");
+		try {
+			writeFileSync(temporary, JSON.stringify({
+				until,
+				boundary,
+				...until < now ? { windowMs } : {}
+			}), { mode: 384 });
+			renameSync(temporary, join(directory, "checkpoint.json"));
+		} finally {
+			rmSync(temporary, { force: true });
+		}
+	});
+	return until < now;
+}
+//#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);
+}
+function removeHostedAppData(home) {
+	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"));
+		}
+	}
+	remove(join(area, "blobs"));
+}
+async function digest$1(path) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path)) hash.update(chunk);
+	return hash.digest("hex");
+}
+function version(value) {
+	if (!/^\d+(?:\.\d+){0,2}$/.test(value)) throw new Error("The app or simulator OS version is unknown.");
+	return value.split(".").map(Number);
+}
+function newer(value, supported) {
+	const required = version(value);
+	const installed = version(supported);
+	for (let index = 0; index < 3; index++) {
+		const difference = (required[index] ?? 0) - (installed[index] ?? 0);
+		if (difference) return difference > 0;
+	}
+	return false;
+}
+/** Materializes only digest-verified manifest content with links contained inside the app bundle. */
+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(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.");
+	rmSync(app, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(app, { mode: 448 });
+	for (const file of record.files) {
+		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 (file.kind === "link") continue;
+		const target = join(app, file.path);
+		mkdirSync(dirname(target), {
+			recursive: true,
+			mode: 448
+		});
+		copyFileSync(blob, target);
+		chmodSync(target, file.kind === "exec" ? 493 : 420);
+	}
+	for (const file of record.files.filter((each) => each.kind === "link")) {
+		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}`);
+		const link = join(app, file.path);
+		mkdirSync(dirname(link), {
+			recursive: true,
+			mode: 448
+		});
+		symlinkSync(target, link);
+	}
+	const root = realpathSync(app);
+	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.");
+	}
+	return {
+		app,
+		root,
+		record
+	};
+}
+async function installHostedApp(home, session, attempt, device, metroPort) {
+	const { app, root, record } = await materializeHostedApp(home, session, attempt);
+	const exec = getExecutor();
+	const plist = (key) => exec.runFile("/usr/libexec/PlistBuddy", [
+		"-c",
+		`Print :${key}`,
+		join(app, "Info.plist")
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	});
+	if (plist("CFBundleIdentifier") !== record.bundleId) throw new Error("The app bundle identity differs from the offered identity.");
+	if (plist("DTPlatformName") !== "iphonesimulator" || !plist("CFBundleSupportedPlatforms").includes("iPhoneSimulator")) throw new Error("The app is not an iOS simulator bundle.");
+	const executable = plist("CFBundleExecutable");
+	if (!executable || /[\\/\0\r\n]/.test(executable) || executable === "." || executable === "..") throw new Error("The app executable is not a bundle-root file.");
+	const binary = realpathSync(join(app, executable));
+	if (!inside(root, binary)) throw new Error("The app executable resolves outside its bundle.");
+	if (!exec.runFile("xcrun", [
+		"lipo",
+		"-archs",
+		binary
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	}).split(/\s+/).includes(device.architecture)) throw new Error("The app has no executable slice for the hosted simulator architecture.");
+	const build = exec.runFile("xcrun", [
+		"vtool",
+		"-arch",
+		device.architecture,
+		"-show-build",
+		binary
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	});
+	const minimum = /^\s*minos\s+(\S+)\s*$/m.exec(build)?.[1];
+	if (!/^\s*platform\s+IOSSIMULATOR\s*$/m.test(build) || !minimum || newer(minimum, device.runtime) || newer(plist("MinimumOSVersion"), device.runtime)) throw new Error("The executable platform or minimum OS is incompatible with the hosted simulator.");
+	assertHostedDeviceLedger(home, device.udid);
+	if (readHostedDevice(home).udid !== device.udid) throw new Error("The hosted device identity changed.");
+	const installed = installIosApp({
+		udid: device.udid,
+		appPath: app,
+		bundleId: record.bundleId,
+		devClientScheme: record.devClientScheme,
+		proveInstalled: false
+	});
+	if (!installed.ok) throw new Error(installed.reason ?? "Hosted app installation was not established.");
+	assertHostedDeviceLedger(home, device.udid);
+	if (readHostedDevice(home).udid !== device.udid) throw new Error("The hosted device identity changed.");
+	const launched = launchIosApp({
+		udid: device.udid,
+		bundleId: record.bundleId,
+		metroPort: record.mode === "development" ? metroPort ?? null : null,
+		devClientScheme: record.devClientScheme
+	});
+	if (!launched.ok) throw new Error(launched.reason ?? "Hosted app 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 (iosAppProcess(device.udid, record.bundleId)) return true;
+	}
+	return "unverified";
+}
+//#endregion
+//#region src/device-host/worker.ts
+function inventory() {
+	return listAllIosSims({ includeUnavailable: true });
+}
+function selectHostedIosDevice(selectors) {
+	inventory();
+	if (readHostMemoryPressure(getExecutor()) !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
+	const selected = resolveIosCreation(selectors);
+	if (!selected.deviceType || !selected.runtime) throw new Error("The installed simulator type or runtime could not be established.");
+	if (process.arch !== "arm64" && process.arch !== "x64") throw new Error("Unsupported simulator host architecture.");
+	return {
+		...selected,
+		deviceType: selected.deviceType,
+		runtime: selected.runtime,
+		architecture: process.arch === "arm64" ? "arm64" : "x86_64"
+	};
+}
+/** Called only in the private server-owned worker home; native effects use Stim's existing ownership and teardown. */
+async function runHostedDevice(mode, selectors, app) {
+	const home = process.env.STIM_HOME;
+	if (!home) throw new Error("Hosted workers require their isolated STIM_HOME.");
+	let device = null;
+	let creationStarted = false;
+	try {
+		if (mode === "prepare") {
+			creationStarted = existsSync(join(home, "hosted-device.json")) || existsSync(join(home, "created-devices.json"));
+			if (creationStarted) throw new Error("This hosted worker home already has a device record. Attach or stop its existing session.");
+			const selected = selectHostedIosDevice(selectors);
+			creationStarted = true;
+			const created = createOwnedIosSim("hosted", {}, selected);
+			device = {
+				...selected,
+				udid: created.udid,
+				name: created.name
+			};
+			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"));
+			});
+			assertHostedDeviceLedger(home, device.udid);
+			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.");
+			return {
+				state: "ready",
+				device
+			};
+		}
+		device = readHostedDevice(home);
+		const ledger = assertHostedDeviceLedger(home, device.udid, "ios", { allowEmpty: mode === "stop" });
+		const current = inventory().find((sim) => sim.udid === device.udid);
+		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);
+			return {
+				state: "installed",
+				device,
+				launched
+			};
+		}
+		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) 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",
+			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(hostedAppBlobs(session, home), 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(hostedAppBlobs(session, home), 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 });
+	return [...devices.emulators, ...devices.unhealthy].some((device) => device.consolePort === port);
+}
+function selectHostedAndroidDevice(request) {
+	if (readHostMemoryPressure(getExecutor()) !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
+	const image = pickDefaultSystemImage(listInstalledSystemImages(), { systemImage: request.systemImage });
+	if (!image || image.arch !== hostSystemImageArch()) throw new Error("No compatible installed Android image.");
+	const profile = request.deviceProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
+	if (!listAvdDeviceProfiles().includes(profile)) throw new Error("The Android device profile is not installed.");
+	return {
+		systemImage: image.pkg,
+		deviceProfile: profile,
+		architecture: image.arch
+	};
+}
+/** Runs only in the private worker home; a caller cannot select or tear down an existing AVD. */
+async function runHostedAndroidDevice(mode, request, app) {
+	const home = process.env.STIM_HOME;
+	if (!home) throw new Error("Hosted workers require their isolated STIM_HOME.");
+	let device = null;
+	let creationStarted = false;
+	try {
+		if (mode === "install") {
+			if (!app) throw new Error("Hosted Android installation needs its admitted app attempt.");
+			device = readHostedDevice(home, "android");
+			const launched = await installHostedAndroidApp(home, request.session, app.attempt, device);
+			return {
+				state: "installed",
+				device,
+				launched
+			};
+		}
+		if (mode === "prepare") {
+			creationStarted = existsSync(join(home, "hosted-device.json")) || existsSync(join(home, "created-devices.json"));
+			if (creationStarted) throw new Error("Attach or stop the existing hosted Android session.");
+			if (!/^[a-f0-9-]{36}$/.test(request.session) || !hostedConsolePort(request.consolePort)) throw new Error("Hosted Android prepare needs its server-selected session and console port.");
+			const choice = selectHostedAndroidDevice(request);
+			const avdName = ownedAvdName(`hosted-${request.session}`);
+			if (listAvds({ timeoutMs: 5e3 }).includes(avdName) || portIsOccupied(request.consolePort)) throw new Error("The hosted AVD name or selected console port is already in use.");
+			const selected = {
+				avdName,
+				serial: `emulator-${request.consolePort}`,
+				consolePort: request.consolePort,
+				...choice
+			};
+			creationStarted = true;
+			await createOwnedAvd(`hosted-${request.session}`, {
+				systemImage: choice.systemImage,
+				deviceProfile: choice.deviceProfile,
+				spawn: (file, args, options) => {
+					assertHostedDeviceLedger(home, avdName, "android");
+					withDirLock(join(home, "hosted-device.lock"), () => {
+						const temporary = join(home, "hosted-device.json.tmp");
+						writeFileSync(temporary, JSON.stringify(selected), { mode: 384 });
+						renameSync(temporary, join(home, "hosted-device.json"));
+					});
+					device = selected;
+					return getExecutor().spawn(file, args, {
+						...options,
+						detached: false
+					});
+				}
+			});
+			assertHostedDeviceLedger(home, avdName, "android");
+			if (portIsOccupied(selected.consolePort)) throw new Error("The selected Android console port became occupied.");
+			bootAndroidEmulator(avdName, selected.consolePort, {
+				openViewer: false,
+				logFile: join(home, "emulator.log")
+			});
+			if (!(await waitForBoot(selected.serial, 24e4, { commandTimeoutMs: 5e3 })).ok || getAvdNameForSerial(selected.serial) !== avdName || androidDeviceAbi(selected.serial) !== selected.architecture) throw new Error("Hosted Android boot could not be verified for its exact owned AVD.");
+			return {
+				state: "ready",
+				device: selected
+			};
+		}
+		device = readHostedDevice(home, "android");
+		const ledger = assertHostedDeviceLedger(home, device.avdName, "android", { allowEmpty: true });
+		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",
+			device,
+			notice: error.message
+		};
+	}
+}
+//#endregion
+//#region src/device-host/macos.ts
+function selectHostedMacos() {
+	if (readHostMemoryPressure(getExecutor()) !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
+	const macosVersion = getExecutor().runFile("sw_vers", ["-productVersion"], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	});
+	if (!/^\d+(\.\d+){0,2}$/.test(macosVersion)) throw new Error("The host macOS version is unknown.");
+	return {
+		architecture: process.arch === "arm64" ? "arm64" : "x86_64",
+		macosVersion
+	};
+}
+function writeRecord(home, file, value) {
+	withDirLock(join(home, "hosted-device.lock"), () => {
+		const temporary = join(home, `${file}.tmp`);
+		writeFileSync(temporary, JSON.stringify(value), { mode: 384 });
+		renameSync(temporary, join(home, file));
+	});
+}
+function preferenceIdentity(home, appSlot) {
+	const file = join(home, "hosted-macos-app.json");
+	if (!existsSync(file)) return null;
+	const stored = JSON.parse(readFileSync(file, "utf8"));
+	if (!isJsonObject(stored) || typeof stored.bundleId !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,248}$/.test(stored.bundleId) || stored.bundleId.startsWith("com.apple.") || !stored.bundleId.endsWith(`.hosted${appSlot}`)) throw new Error("The hosted macOS preference identity is malformed.");
+	return stored.bundleId;
+}
+function removePreferences(bundleId) {
+	const exec = getExecutor();
+	const options = {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	};
+	exec.runFileQuiet("defaults", ["delete", bundleId], options);
+	const file = join(homedir(), "Library", "Preferences", `${bundleId}.plist`);
+	rmSync(file, { force: true });
+	if (existsSync(file)) throw new Error("The hosted macOS preferences plist still exists after deletion.");
+	try {
+		exec.runFile("defaults", ["read", bundleId], options);
+	} catch (error) {
+		if (/not found|does not exist/i.test(error.message)) return;
+		throw error;
+	}
+	throw new Error("The hosted macOS preference domain is still readable after deletion.");
+}
+function assertInside(root, path) {
+	const diff = relative(root, realpathSync(path));
+	if (!diff || diff === ".." || diff.startsWith(`..${sep}`) || isAbsolute(diff)) throw new Error("Hosted macOS app data resolves outside its private area.");
+}
+function removeAppData(root, path) {
+	try {
+		lstatSync(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	assertInside(root, path);
+	rmSync(path, {
+		recursive: true,
+		force: true
+	});
+}
+async function runHostedMacosApp(mode, request, app) {
+	const home = process.env.STIM_HOME;
+	let device = null;
+	let recorded = false;
+	try {
+		if (!home) throw new Error("Hosted workers require their isolated STIM_HOME.");
+		if (!hostedMacosAppSlot(request.appSlot)) throw new Error("Hosted macOS workers require a reserved app slot.");
+		if (mode === "prepare") {
+			recorded = existsSync(join(home, "hosted-device.json"));
+			if (recorded) throw new Error("Attach or stop the existing hosted macOS session.");
+			const selected = {
+				...selectHostedMacos(),
+				appSlot: request.appSlot
+			};
+			assertHostedDeviceLedger(home, `macos-${request.appSlot}`, "macos");
+			writeRecord(home, "hosted-device.json", selected);
+			recorded = true;
+			device = selected;
+			return {
+				state: "ready",
+				device
+			};
+		}
+		device = readHostedDevice(home, "macos");
+		if (device.appSlot !== request.appSlot) throw new Error("The hosted macOS app slot changed.");
+		assertHostedDeviceLedger(home, `macos-${device.appSlot}`, "macos");
+		const runRoot = join(realpathSync(home), "macos-app");
+		if (mode === "stop") {
+			if (requiredMacosRecord(runRoot)) await stopMacosAppHeld(runRoot);
+			const bundleId = preferenceIdentity(home, device.appSlot);
+			if (bundleId) removePreferences(bundleId);
+			const area = realpathSync(join(home, ".."));
+			assertInside(area, home);
+			removeAppData(realpathSync(home), join(home, "app-home"));
+			const apps = join(home, "..", "apps");
+			if (existsSync(apps)) {
+				assertInside(area, apps);
+				for (const attempt of readdirSync(apps)) {
+					const directory = join(apps, attempt);
+					assertInside(area, directory);
+					removeAppData(area, join(directory, "App.app"));
+					removeAppData(area, join(directory, "blobs"));
+				}
+			}
+			removeAppData(area, join(home, "..", "blobs"));
+			return {
+				state: "stopped",
+				device
+			};
+		}
+		if (!app) throw new Error("Hosted macOS installation needs its admitted app attempt.");
+		const { app: bundle, root, record } = await materializeHostedApp(home, request.session, app.attempt);
+		const exec = getExecutor();
+		const options = {
+			timeoutMs: 1e4,
+			killSignal: "SIGKILL"
+		};
+		const plistPath = join(bundle, "Contents", "Info.plist");
+		const plist = JSON.parse(exec.runFile("plutil", [
+			"-convert",
+			"json",
+			"-o",
+			"-",
+			plistPath
+		], options));
+		if (!isJsonObject(plist) || plist.CFBundleIdentifier !== record.bundleId) throw new Error("The app bundle identity differs from the offered identity.");
+		const product = plist.CFBundleExecutable;
+		if (typeof product !== "string" || !product || /[\\/\0\r\n]/.test(product) || product === "." || product === "..") throw new Error("The app executable must be a single path component.");
+		if (plist.CFBundleURLTypes !== void 0 || plist.SUFeedURL !== void 0) throw new Error("Hosted macOS apps cannot register shared URL schemes or an update feed.");
+		if (plist.LSMinimumSystemVersion !== void 0 && (typeof plist.LSMinimumSystemVersion !== "string" || newer(plist.LSMinimumSystemVersion, device.macosVersion))) throw new Error("The app minimum OS is incompatible with the hosted Mac.");
+		const executable = realpathSync(join(bundle, "Contents", "MacOS", product));
+		const diff = relative(root, executable);
+		if (!diff || diff === ".." || diff.startsWith(`..${sep}`) || isAbsolute(diff)) throw new Error("The app executable resolves outside its bundle.");
+		if (!exec.runFile("xcrun", [
+			"lipo",
+			"-archs",
+			executable
+		], options).split(/\s+/).includes(device.architecture)) throw new Error("The app has no executable slice for the hosted Mac architecture.");
+		const build = exec.runFile("xcrun", [
+			"vtool",
+			"-arch",
+			device.architecture,
+			"-show-build",
+			executable
+		], options);
+		const minimum = /^\s*minos\s+(\S+)\s*$/m.exec(build)?.[1];
+		if (!/^\s*platform\s+MACOS\s*$/m.test(build) || !minimum || newer(minimum, device.macosVersion)) throw new Error("The executable platform or minimum OS is incompatible with the hosted Mac.");
+		const bundleId = hostedMacosBundleId(record.bundleId, device.appSlot);
+		exec.runFile("/usr/libexec/PlistBuddy", [
+			"-c",
+			`Set :CFBundleIdentifier ${bundleId}`,
+			plistPath
+		], options);
+		const frameworks = join(bundle, "Contents", "Frameworks");
+		if (existsSync(frameworks)) {
+			for (const entry of readdirSync(frameworks)) if (entry.endsWith(".framework")) exec.runFile("codesign", [
+				"--force",
+				"--sign",
+				"-",
+				join(frameworks, entry)
+			], options);
+		}
+		exec.runFile("codesign", [
+			"--force",
+			"--sign",
+			"-",
+			bundle
+		], options);
+		if (requiredMacosRecord(runRoot)) await stopMacosAppHeld(runRoot);
+		const previousId = preferenceIdentity(home, device.appSlot);
+		if (previousId && previousId !== bundleId) removePreferences(previousId);
+		mkdirSync(runRoot, {
+			recursive: true,
+			mode: 448
+		});
+		const canonicalRunRoot = realpathSync(runRoot);
+		ensureWorkspaceStorage(canonicalRunRoot);
+		const launch = {
+			product,
+			bundle: root,
+			bundleId,
+			executable,
+			arguments: record.arguments ?? [],
+			launchId: randomUUID(),
+			supervisor: macosProcess(process.pid),
+			build: {
+				state: "ok",
+				startedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		writeRecord(home, "hosted-macos-app.json", { bundleId });
+		writeWorkspaceState(canonicalRunRoot, { macos: launch });
+		const isolated = join(home, "app-home");
+		const temporary = join(isolated, "tmp");
+		mkdirSync(isolated, {
+			recursive: true,
+			mode: 448
+		});
+		mkdirSync(temporary, {
+			mode: 448,
+			recursive: true
+		});
+		const fd = openSync(join(home, "macos-supervisor.log"), "a", 384);
+		let child;
+		let spawnError;
+		const env = {};
+		for (const key of [
+			"PATH",
+			"LANG",
+			"LC_ALL",
+			"LC_CTYPE",
+			"USER",
+			"LOGNAME",
+			"SHELL",
+			"TERM"
+		]) if (process.env[key] !== void 0) env[key] = process.env[key];
+		Object.assign(env, {
+			STIM_HOME: home,
+			HOME: isolated,
+			CFFIXED_USER_HOME: isolated,
+			TMPDIR: temporary
+		});
+		try {
+			child = exec.spawn(process.execPath, [
+				spawnEntry("macos-run"),
+				canonicalRunRoot,
+				launch.launchId
+			], {
+				detached: true,
+				stdio: [
+					"ignore",
+					fd,
+					fd
+				],
+				cwd: canonicalRunRoot,
+				env
+			});
+			child.once("error", (error) => {
+				spawnError = error;
+			});
+			child.unref();
+		} finally {
+			closeSync(fd);
+		}
+		const deadline = Date.now() + 2e4;
+		while (Date.now() < deadline) {
+			if (spawnError) throw spawnError;
+			const current = readMacosRecord(canonicalRunRoot);
+			if (current?.launchId === launch.launchId && current.app && current.supervisor && (0, process_identity_exports.inspectProcessIdentity)(current.app) === "same" && (0, process_identity_exports.inspectProcessIdentity)(current.supervisor) === "same") return {
+				state: "installed",
+				device,
+				launched: true,
+				pid: current.app.pid
+			};
+			if (child.exitCode !== null || child.signalCode !== null) break;
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		throw new Error("The hosted macOS app did not register. See macos-supervisor.log in the worker home.");
+	} catch (error) {
+		return {
+			state: mode === "prepare" && !recorded && !device && !(home && existsSync(join(home, "hosted-device.json"))) ? "stopped" : "unknown",
+			device,
+			notice: error.message
+		};
+	}
+}
+//#endregion
+//#region src/device-host/offer.ts
+function inspectHostedDevice(request) {
+	const cpus = availableParallelism();
+	let workerDiskFreeBytes = null;
+	try {
+		const disk = statfsSync(configDir());
+		workerDiskFreeBytes = disk.bavail * disk.bsize;
+	} catch {}
+	const resources = {
+		cpus,
+		loadPerCore: loadavg()[1] / cpus,
+		memoryFreeBytes: freemem(),
+		memoryPressure: readHostMemoryPressure(),
+		workerDiskFreeBytes
+	};
+	try {
+		if (process.platform !== "darwin") throw new Error("Hosted device sessions require a Mac.");
+		if (resources.memoryPressure !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
+		return request.platform === "macos" ? {
+			platform: "macos",
+			choice: selectHostedMacos(),
+			resources,
+			declined: null
+		} : request.platform === "ios" ? {
+			platform: "ios",
+			choice: selectHostedIosDevice(request),
+			resources,
+			declined: null
+		} : {
+			platform: "android",
+			choice: selectHostedAndroidDevice(request),
+			resources,
+			declined: null
+		};
+	} catch (error) {
+		return {
+			platform: request.platform,
+			choice: null,
+			resources,
+			declined: error.message.slice(0, 4e3)
+		};
+	}
+}
+//#endregion
+//#region src/device-host/run.ts
+async function main() {
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of process.stdin) {
+		bytes += chunk.length;
+		if (bytes > 8192) throw new Error("Hosted worker request is too large.");
+		chunks.push(chunk);
+	}
+	const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	if (!isJsonObject(input) || ![
+		"prepare",
+		"stop",
+		"install",
+		"offer",
+		"logs"
+	].includes(String(input.mode))) throw new Error("Invalid hosted worker request.");
+	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`);
+		return;
+	}
+	if (process.platform !== "darwin") {
+		process.stdout.write(`${JSON.stringify({
+			state: input.mode === "prepare" ? "stopped" : "unknown",
+			device: null,
+			notice: "Hosted device sessions require a Mac."
+		})}\n`);
+		return;
+	}
+	if ((input.mode === "install" || input.mode === "logs") && (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.platform === "macos" && !hostedMacosAppSlot(input.appSlot)) throw new Error("Invalid hosted macOS app slot.");
+	if (input.mode === "logs") {
+		if (input.platform !== "ios" || !process.env.STIM_HOME || typeof input.since !== "number" || !Number.isFinite(input.since)) throw new Error("Invalid hosted iOS log request.");
+		const more = 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
+	}, input.mode === "install" ? { attempt: input.attempt } : void 0) : input.platform === "android" ? await runHostedAndroidDevice(input.mode, {
+		session: typeof input.session === "string" ? input.session : "",
+		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, {
+		...typeof input.deviceType === "string" ? { deviceType: input.deviceType } : {},
+		...typeof input.runtime === "string" ? { runtime: input.runtime } : {}
+	}, input.mode === "install" ? {
+		session: input.session,
+		attempt: input.attempt,
+		...typeof input.metroPort === "number" ? { metroPort: input.metroPort } : {}
+	} : void 0);
+	process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+main().catch((error) => {
+	process.stderr.write(`${String(error.message ?? error)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};