stim 1.13.0 → 1.15.0

package/dist/supervisor-run.d.mts

@@ -1,19 +1,43 @@
 import { t as NdjsonWriter } from "./ndjson-Du3j0AQ9.mjs";
-import "@stim-cli/core/state";
+import { a as readPidFile, i as clearWorkspaceSupervisor, n as MODE_EXPO, o as writePidFile, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-B4PQFXMW.mjs";
+import { DevServerStopRecord, DeviceActivity, IOS_SIMULATOR_APPS } from "@stim-cli/core/state";
 //#region src/supervisor/idle-stop.d.ts
 interface IdleProbe {
   lastActivityAt(): number;
   blocker(): string | null;
 }
-import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
 //#endregion
-//#region src/supervisor/state.d.ts
-declare const MODE_BARE = "bare-inproc";
-declare const MODE_EXPO = "expo-child";
-declare function clearWorkspaceSupervisor(root: string, expected?: process_identity_d_exports.ProcessRecord | null): boolean;
-declare function clearExpoMetroTunnel(root: string): void;
-declare function writePidFile(root: string, pid: number): string;
-declare function readPidFile(root: string): number | null;
+//#region src/commands/gc/idle.d.ts
+interface OwnedDeviceActivity {
+  kind: "ios" | "android";
+  id: string;
+  name: string;
+  project: string;
+  slot: string;
+  activity: DeviceActivity;
+}
+//#endregion
+//#region src/devices/idle-shutdown.d.ts
+interface DueDevice {
+  device: OwnedDeviceActivity;
+  idleForMs: number;
+}
+/** The workspace's booted owned simulators and emulators that have been idle for `idleMs` or more. */
+declare function dueIdleDevices(root: string, idleMs: number, now?: number): DueDevice[];
+interface IdleShutdownEvent {
+  level: "info" | "warn";
+  event: "device_idle_shutdown" | "device_idle_shutdown_failed";
+  msg: string;
+}
+/**
+ * Shuts down, through centralized teardown, each of the workspace's owned devices that is still idle for `idleMs`,
+ * and records why. The caller holds the workspace's native-run lock, so no `ios` or `android` run is booting or
+ * installing on them.
+ */
+declare function shutDownIdleDevices(root: string, idleMs: number, log: (event: IdleShutdownEvent) => void, now?: number): number;
+//#endregion
+//#region src/watchman.d.ts
+type WatchmanCommand = (args: string[], timeoutMs: number) => Promise<unknown>;
 //#endregion
 //#region src/supervisor/run.d.ts
 interface ParsedSupervisorArgs {
@@ -22,6 +46,7 @@ interface ParsedSupervisorArgs {
   tunnel?: boolean;
   resetCache?: boolean;
   idleStopMinutes?: number;
+  deviceIdleMinutes?: number;
   error?: string;
 }
 declare function parseArgs(argv: string[]): ParsedSupervisorArgs;
@@ -45,6 +70,10 @@ type ServerStarter = (opts: {
   resetCache?: boolean;
   onTunnelUrl?: ((url: string) => void) | null;
 }) => Promise<ServerHandle>;
+interface DeviceIdleOps {
+  due: typeof dueIdleDevices;
+  shutDown: typeof shutDownIdleDevices;
+}
 interface RunSupervisorOptions {
   root: string;
   port: number;
@@ -52,6 +81,8 @@ interface RunSupervisorOptions {
   resetCache?: boolean;
   idleStopMinutes?: number;
   idleProbe?: IdleProbe;
+  deviceIdleMinutes?: number;
+  deviceIdle?: DeviceIdleOps;
   isExpo?: (projectRoot: string) => boolean;
   startBare?: ServerStarter | null;
   startExpo?: ServerStarter | null;
@@ -59,13 +90,14 @@ interface RunSupervisorOptions {
   onExit?: (code: number) => void;
   attachSignals?: boolean;
   stderr?: (line: string) => void;
+  watchman?: WatchmanCommand;
 }
-declare function runSupervisor({ root, port, tunnel, resetCache, idleStopMinutes, idleProbe, isExpo, startBare, startExpo, now, onExit, attachSignals, stderr }: RunSupervisorOptions): Promise<{
+declare function runSupervisor({ root, port, tunnel, resetCache, idleStopMinutes, idleProbe, deviceIdleMinutes, deviceIdle, isExpo, startBare, startExpo, now, onExit, attachSignals, stderr, watchman }: RunSupervisorOptions): Promise<{
   mode: string;
   server: ServerHandle | undefined;
-  shutdown: (code: number, event: string, msg: string) => Promise<void>;
+  shutdown: (code: number, event: string, msg: string, stop?: DevServerStopRecord) => Promise<void>;
   startedAt: string;
 } | null>;
 declare function main(argv?: string[]): Promise<void>;
 //#endregion
-export { MODE_BARE, MODE_EXPO, RunSupervisorOptions, ServerExitInfo, ServerHandle, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, runSupervisor, writePidFile };
+export { DeviceIdleOps, MODE_BARE, MODE_EXPO, RunSupervisorOptions, ServerExitInfo, ServerHandle, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, runSupervisor, writePidFile };

package/dist/supervisor-run.mjs

@@ -1,20 +1,23 @@
-import { O as process_identity_exports, U as projectDeviceSlots, V as parseDeviceSlotKey, o as clearSupervisor, p as getProject, w as setSupervisor } from "./config-0jCcMM0E.mjs";
+import { B as parseDeviceSlotKey, H as projectDeviceSlots, T as setSupervisor, o as clearSupervisor, p as getProject } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir, b as writeWorkspaceState, h as readWorkspaceState$1, m as clearWorkspaceStateKeys, v as withWorkspaceStateLock } from "./metro-BPeY1YMh.mjs";
-import { r as detectIsExpo } from "./project-DGeclhvO.mjs";
+import { C as workspaceLogsDir, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
+import { r as detectIsExpo } from "./project-CV3tDFHl.mjs";
 import { t as describeError } from "./errors-B6W7FkxQ.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-DJHoca49.mjs";
-import { l as readPidFile, n as MODE_EXPO, p as writePidFile, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-DwAU2_-D.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-n7tnJsI8.mjs";
-import { a as parseLease, r as leaseIsExpired, s as parseWorkspaceLeases, t as deviceLeasePath } from "./device-lease-CL9dZf73.mjs";
-import { n as createActivityReader } from "./activity-DfVKZTEB.mjs";
-import { R as ownedAvdSerialResolver } from "./android-qx_31wJo.mjs";
-import { s as workspaceBuildInProgress } from "./idle-DxLi5OkN.mjs";
-import { n as withIdleWorkspace } from "./in-use-wYEaKQM9.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
+import { l as readPidFile, n as MODE_EXPO, p as writePidFile, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-CaeaHbDA.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { n as createActivityReader } from "./activity-B2-kb7k0.mjs";
+import { a as parseLease, r as leaseIsExpired, s as parseWorkspaceLeases, t as deviceLeasePath } from "./device-lease-W5Pi1q38.mjs";
+import { z as ownedAvdSerialResolver } from "./android-Db2eEMaf.mjs";
+import { n as parseTriggerCount, o as runWatchman, p as workspaceBuildInProgress, r as parseWatchRoots, t as parseSubscriberNames } from "./watchman-Bx0wceoF.mjs";
+import { n as withIdleWorkspace } from "./in-use-CndPMilN.mjs";
+import { n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-B5LPaNyY.mjs";
+import { c as vanishedSupervisorMessage, i as devServerStopRecord, r as devServerStopLevel, t as describeDevServerStop } from "./stop-cause-CZ_Mr-v9.mjs";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { LOG_ROTATE_BYTES } from "@stim-cli/core";
-import { IDLE_STOP_KEY } from "@stim-cli/core/state";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { DEV_SERVER_STOP_REQUEST_KEY, IDLE_STOP_KEY, readDevServerStopRequest } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
 //#region src/supervisor/idle-stop.ts
 const IDLE_CHECK_MS = 6e4;
@@ -125,15 +128,163 @@ function watchIdleDevServer({ idleStopMs, now, serverActivityAt, probe, onIdle,
 	timer.unref?.();
 	return () => clearInterval(timer);
 }
+/**
+* Checks each minute, once the workspace has gone `idleMs` without a Stim command, whether an owned device is due
+* for idle shutdown, and runs `onDue` for it.
+*/
+function watchIdleDevices({ idleMs, now, lastUseAt, hasDue, onDue, checkMs = IDLE_CHECK_MS }) {
+	let deciding = false;
+	const timer = setInterval(() => {
+		if (deciding || now() - lastUseAt() < idleMs) return;
+		let due;
+		try {
+			due = hasDue();
+		} catch {
+			return;
+		}
+		if (!due) return;
+		deciding = true;
+		onDue().finally(() => {
+			deciding = false;
+		});
+	}, Math.min(checkMs, idleMs));
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+//#endregion
+//#region src/supervisor/watchman-roots.ts
+const WATCHMAN_TIMEOUT_MS = 2e3;
+const SHUTDOWN_BUDGET_MS = 3e3;
+const PROBE_DELAYS_MS = [
+	3e3,
+	6e3,
+	1e4,
+	15e3,
+	2e4,
+	3e4,
+	45e3,
+	6e4,
+	12e4,
+	3e5
+];
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+function newRootsContaining(before, current, workspaceRoot) {
+	const seen = new Set(before.map((root) => canonical(root) ?? root));
+	return current.filter((root) => {
+		const resolved = canonical(root);
+		if (resolved === null || seen.has(resolved)) return false;
+		return workspaceRoot === resolved || workspaceRoot.startsWith(resolved.endsWith(sep) ? resolved : resolved + sep);
+	});
+}
+function metroSubscriptionPrefix(pid) {
+	return `metro-file-map-${pid}-`;
+}
+async function watchRoots(watchman) {
+	try {
+		return parseWatchRoots(await watchman(["watch-list"]));
+	} catch {
+		return null;
+	}
+}
+async function subscriberNames(watchman, root) {
+	try {
+		return parseSubscriberNames(await watchman(["debug-get-subscriptions", root]));
+	} catch {
+		return null;
+	}
+}
+async function triggerCount(watchman, root) {
+	try {
+		return parseTriggerCount(await watchman(["trigger-list", root]));
+	} catch {
+		return null;
+	}
+}
+function trackMetroWatchRoots({ workspaceRoot, writer, watchman = runWatchman, probeDelaysMs = PROBE_DELAYS_MS }) {
+	let deadline = Infinity;
+	const call = async (args) => {
+		const left = deadline - Date.now();
+		if (left <= 0) throw new Error("the watchman cleanup ran out of time");
+		return watchman(args, Math.min(WATCHMAN_TIMEOUT_MS, left));
+	};
+	const before = watchRoots(call);
+	const owned = /* @__PURE__ */ new Set();
+	const timers = [];
+	let prefix = null;
+	const probe = async () => {
+		const earlier = await before;
+		if (prefix === null || earlier === null) return;
+		const current = await watchRoots(call);
+		if (current === null) return;
+		for (const root of newRootsContaining(earlier, current, workspaceRoot)) {
+			if (owned.has(root)) continue;
+			if ((await subscriberNames(call, root))?.some((name) => name.startsWith(prefix))) owned.add(root);
+		}
+	};
+	return {
+		started(metroPid) {
+			prefix = metroSubscriptionPrefix(metroPid);
+			for (const delay of probeDelaysMs) {
+				const timer = setTimeout(() => void probe(), delay);
+				timer.unref?.();
+				timers.push(timer);
+			}
+		},
+		async beforeClose() {
+			for (const timer of timers) clearTimeout(timer);
+			deadline = Date.now() + SHUTDOWN_BUDGET_MS;
+			await probe();
+		},
+		async afterClose() {
+			for (const root of owned) {
+				const others = (await subscriberNames(call, root))?.filter((name) => !name.startsWith(prefix));
+				const triggers = others?.length === 0 ? await triggerCount(call, root) : null;
+				const reason = !others ? "could not list its subscriptions" : others.length > 0 ? `${others.length} other subscription(s) still use it` : triggers === null ? "could not list its triggers" : triggers > 0 ? `it has ${triggers} trigger(s)` : null;
+				if (reason) {
+					writer.write({
+						src: "metro",
+						level: "debug",
+						event: "watchman_root_kept",
+						msg: `kept the watchman root ${root}: ${reason}`
+					});
+					continue;
+				}
+				try {
+					await call(["watch-del", root]);
+					writer.write({
+						src: "metro",
+						level: "info",
+						event: "watchman_root_removed",
+						msg: `removed the watchman root ${root} that this dev server registered`
+					});
+				} catch (err) {
+					writer.write({
+						src: "metro",
+						level: "warn",
+						event: "watchman_root_kept",
+						msg: `could not remove the watchman root ${root}: ${describeError(err)}`
+					});
+				}
+			}
+		}
+	};
+}
 //#endregion
 //#region src/supervisor/run.ts
-const USAGE = "Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache] [--idle-stop-minutes <n>]";
+const USAGE = "Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache] [--idle-stop-minutes <n>] [--device-idle-minutes <n>]";
 function parseArgs(argv) {
 	let root;
 	let port;
 	let tunnel = false;
 	let resetCache = false;
 	let idleStopMinutes = "0";
+	let deviceIdleMinutes = "0";
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
 		if (arg === "--root") {
@@ -156,22 +307,31 @@ function parseArgs(argv) {
 			idleStopMinutes = argv[++i] ?? "";
 			continue;
 		}
+		if (arg === "--device-idle-minutes") {
+			deviceIdleMinutes = argv[++i] ?? "";
+			continue;
+		}
 		return { error: `Unknown supervisor argument "${arg}". ${USAGE}` };
 	}
 	if (!root) return { error: `Missing --root. ${USAGE}` };
 	if (!isAbsolute(root)) return { error: `--root must be an absolute path, got "${root}".` };
 	const parsedPort = Number(port);
 	if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) return { error: `--port must be a TCP port number, got "${port}".` };
-	if (!/^\d+$/.test(idleStopMinutes)) return { error: `--idle-stop-minutes must be a whole number of minutes, got "${idleStopMinutes}".` };
+	for (const [flag, value] of [["--idle-stop-minutes", idleStopMinutes], ["--device-idle-minutes", deviceIdleMinutes]]) if (!/^\d+$/.test(value)) return { error: `${flag} must be a whole number of minutes, got "${value}".` };
 	return {
 		root: resolve(root),
 		port: parsedPort,
 		tunnel,
 		resetCache,
-		idleStopMinutes: Number(idleStopMinutes)
+		idleStopMinutes: Number(idleStopMinutes),
+		deviceIdleMinutes: Number(deviceIdleMinutes)
 	};
 }
-async function runSupervisor({ root, port, tunnel = false, resetCache = false, idleStopMinutes = 0, idleProbe, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
+const DEVICE_IDLE_OPS = {
+	due: dueIdleDevices,
+	shutDown: shutDownIdleDevices
+};
+async function runSupervisor({ root, port, tunnel = false, resetCache = false, idleStopMinutes = 0, idleProbe, deviceIdleMinutes = 0, deviceIdle = DEVICE_IDLE_OPS, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line), watchman = runWatchman }) {
 	root = realpathSync(root);
 	const logsDir = workspaceLogsDir(root);
 	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
@@ -191,6 +351,13 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		mode,
 		startedAt
 	};
+	const vanished = vanishedSupervisorMessage(readWorkspaceState$1(root)?.supervisor);
+	if (vanished) writer.write({
+		src: "metro",
+		level: "warn",
+		event: "supervisor_vanished",
+		msg: vanished
+	});
 	clearExpoMetroTunnel(root);
 	writePidFile(root, process.pid);
 	writeWorkspaceState(root, { supervisor: record });
@@ -214,14 +381,29 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 	});
 	let stopping = false;
 	let stopWatchingIdle = null;
-	const finish = (code, event, level, msg) => {
+	let stopWatchingDevices = null;
+	const stopCause = (trigger) => {
+		const request = readDevServerStopRequest(readWorkspaceState$1(root));
+		return devServerStopRecord(trigger, request?.processToken === processToken ? request : null, new Date(now()).toISOString());
+	};
+	const finish = (code, event, level, msg, stop) => {
 		stopWatchingIdle?.();
+		stopWatchingDevices?.();
 		writer.write({
 			src: "metro",
 			level,
 			event,
-			msg
+			msg,
+			...stop ? { stop } : {}
 		});
+		try {
+			withWorkspaceStateLock(root, () => {
+				const current = readWorkspaceState$1(root)?.supervisor;
+				if (current && current.processToken !== processToken) return;
+				if (stop) writeWorkspaceState(root, { [IDLE_STOP_KEY]: stop });
+				clearWorkspaceStateKeys(root, [DEV_SERVER_STOP_REQUEST_KEY]);
+			});
+		} catch {}
 		try {
 			clearSupervisor(root, record);
 		} catch {}
@@ -233,10 +415,17 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		onExit(code);
 	};
 	let server;
-	const shutdown = async (code, event, msg) => {
+	const watchRoots = trackMetroWatchRoots({
+		workspaceRoot: root,
+		writer,
+		watchman
+	});
+	const shutdown = async (code, event, msg, stop) => {
 		if (stopping || !server) return;
 		stopping = true;
 		stopWatchingIdle?.();
+		stopWatchingDevices?.();
+		await watchRoots.beforeClose();
 		try {
 			await server.close();
 		} catch (err) {
@@ -247,16 +436,25 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 				msg: describeError(err)
 			});
 		}
-		finish(code, event, code === 0 ? "info" : "error", msg);
+		await watchRoots.afterClose();
+		finish(code, event, stop ? devServerStopLevel(stop) : code === 0 ? "info" : "error", msg, stop);
 	};
 	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
 		if (server) {
-			shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
+			const stop = stopCause({
+				kind: "signal",
+				signal
+			});
+			shutdown(0, "supervisor_stopped", `stopping the ${mode} dev server: ${describeDevServerStop(stop)}`, stop);
 			return;
 		}
 		if (stopping) return;
 		stopping = true;
-		finish(signal === "SIGINT" ? 130 : 143, "supervisor_stopped", "warn", `received ${signal} before the ${mode} dev server started; stopping`);
+		const stop = stopCause({
+			kind: "signal",
+			signal
+		});
+		finish(signal === "SIGINT" ? 130 : 143, "supervisor_stopped", "warn", `stopping before the ${mode} dev server started: ${describeDevServerStop(stop)}`, stop);
 	});
 	const serverActivity = trackDevServerActivity(now);
 	const serverWriter = Object.assign(Object.create(writer), { write(entry) {
@@ -264,7 +462,7 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		return writer.write(entry);
 	} });
 	try {
-		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-BeYwP_Xy.mjs")).startExpoServer : startBare || (await import("./server-bare-Bq8BpSIo.mjs")).startBareServer)({
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-KJeD109I.mjs")).startExpoServer : startBare || (await import("./server-bare-X7PUgizL.mjs")).startBareServer)({
 			root,
 			port,
 			logsDir,
@@ -313,12 +511,45 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			} });
 		});
 	}
+	watchRoots.started(serverPid ?? process.pid);
 	writer.write({
 		src: "metro",
 		level: "info",
 		event: "server_started",
 		msg: `${mode} dev server listening on port ${port}`
 	});
+	const deviceIdleMs = deviceIdleMinutes * 6e4;
+	const workspaceProbe = workspaceIdleProbe(root);
+	const shutDownIdleDevices = (idleMs) => deviceIdle.shutDown(root, idleMs, (entry) => writer.write({
+		src: "metro",
+		...entry
+	}));
+	if (deviceIdleMinutes > 0) stopWatchingDevices = watchIdleDevices({
+		idleMs: deviceIdleMs,
+		now,
+		lastUseAt: () => {
+			let deviceLog = NaN;
+			try {
+				deviceLog = statSync(join(logsDir, "device.ndjson")).mtimeMs;
+			} catch {}
+			const times = [workspaceProbe.lastActivityAt(), deviceLog].filter(Number.isFinite);
+			return times.length ? Math.max(...times) : NaN;
+		},
+		hasDue: () => deviceIdle.due(root, deviceIdleMs).length > 0,
+		onDue: async () => {
+			try {
+				await withIdleWorkspace(root, () => {
+					if (!stopping) shutDownIdleDevices(deviceIdleMs);
+				}, {
+					purpose: "device idle shutdown",
+					supervisor: false,
+					managedLocks: false
+				});
+			} catch (err) {
+				stderr(`Stim supervisor: could not shut down idle devices: ${describeError(err)}`);
+			}
+		}
+	});
 	if (idleStopMinutes > 0) stopWatchingIdle = watchIdleDevServer({
 		idleStopMs: idleStopMinutes * 6e4,
 		now,
@@ -328,14 +559,20 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			const stopIfStillIdle = async () => {
 				const idleMinutes = idleMinutesNow();
 				if (stopping || idleMinutes === null) return;
+				if (deviceIdleMinutes > 0) try {
+					shutDownIdleDevices(Math.min(deviceIdleMs, idleStopMinutes * 6e4));
+				} catch (err) {
+					stderr(`Stim supervisor: could not shut down idle devices: ${describeError(err)}`);
+				}
+				const stop = {
+					reason: "idle",
+					at: new Date(now()).toISOString(),
+					idleMinutes
+				};
 				withWorkspaceStateLock(root, () => {
-					if (readWorkspaceState$1(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { [IDLE_STOP_KEY]: {
-						reason: "idle",
-						at: new Date(now()).toISOString(),
-						idleMinutes
-					} });
+					if (readWorkspaceState$1(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { [IDLE_STOP_KEY]: stop });
 				});
-				await shutdown(0, "supervisor_idle_stopped", `no bundle request, client log or Stim command for ${idleMinutes} minutes (metro.idleStopMinutes is ${idleStopMinutes}); stopped the ${mode} dev server`);
+				await shutdown(0, "supervisor_idle_stopped", `no bundle request, client log or Stim command for ${idleMinutes} minutes (metro.idleStopMinutes is ${idleStopMinutes}); stopped the ${mode} dev server`, stop);
 			};
 			try {
 				await withIdleWorkspace(root, () => withWorkspaceProcessLock(dirname(logsDir), "metro-start", stopIfStillIdle, {
@@ -354,8 +591,13 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 	});
 	server.onExit?.((info) => {
 		if (stopping) return;
-		const detail = info?.signal ? `signal ${info.signal}` : `exit code ${info?.code ?? "unknown"}`;
-		shutdown(1, "supervisor_stopped", `the ${mode} dev server exited unexpectedly (${detail}); shutting the supervisor down`);
+		const stop = stopCause({
+			kind: "server-exit",
+			mode,
+			code: info?.code ?? null,
+			signal: info?.signal ?? null
+		});
+		shutdown(stop.reason === "requested" ? 0 : 1, "supervisor_stopped", stop.reason === "requested" ? `the ${mode} dev server exited; ${describeDevServerStop(stop)}` : `${describeDevServerStop(stop)}; shutting the supervisor down`, stop);
 	});
 	return {
 		mode,
@@ -387,7 +629,8 @@ async function main(argv = process.argv.slice(2)) {
 		port: parsed.port,
 		tunnel: parsed.tunnel ?? false,
 		resetCache: parsed.resetCache ?? false,
-		idleStopMinutes: parsed.idleStopMinutes ?? 0
+		idleStopMinutes: parsed.idleStopMinutes ?? 0,
+		deviceIdleMinutes: parsed.deviceIdleMinutes ?? 0
 	});
 }
 function invokedDirectly() {