stim 1.14.0 → 1.16.0

package/dist/status-DlKvVJBE.mjs

@@ -0,0 +1,49 @@
+import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
+import { maintenanceRunClaims, readMaintenanceState } from "@stim-cli/core/state";
+import { claimRemoveCommand, readClaimSet } from "@stim-cli/core/ownership-claim";
+//#region src/maintenance/status.ts
+function maintenanceStatus() {
+	const state = readMaintenanceState();
+	const claims = readClaimSet(maintenanceRunClaims());
+	const holder = claims.live[0];
+	const unresolved = claims.unresolved[0];
+	const settings = resolveMaintenanceSettings();
+	return {
+		mode: settings.mode,
+		...settings.invalid ? { invalid: settings.invalid } : {},
+		...unresolved ? { claim: {
+			unresolved: `${unresolved.path}: ${unresolved.reason}`,
+			removeCommand: claimRemoveCommand(unresolved.path)
+		} } : {},
+		lastChecks: {
+			pressure: state?.lastAt.pressure ?? null,
+			size: state?.lastAt.size ?? null
+		},
+		pressure: state?.pressure ?? null,
+		sizes: state?.sizes ?? [],
+		lastPass: state?.lastPass ?? null,
+		running: holder ? {
+			startedAt: holder.startedAt,
+			trigger: String(holder.details.trigger ?? "command")
+		} : null,
+		recent: state?.recent ?? [],
+		plan: state?.plan ?? []
+	};
+}
+function maintenanceLine(status, includeLabel = true) {
+	if (status.mode === "off" && !status.lastPass && !status.running && !status.invalid && !status.claim) return null;
+	const at = status.lastPass ? new Date(status.lastPass.startedAt).toLocaleTimeString("en-GB", {
+		hour: "2-digit",
+		minute: "2-digit"
+	}) : null;
+	const outputs = status.plan.filter((action) => action.kind === "would-clear-outputs");
+	const summary = outputs.length ? `would clear build outputs of ${outputs.length} ${outputs.length === 1 ? "workspace" : "workspaces"} (${(outputs.reduce((sum, action) => sum + action.bytes, 0) / 1024 ** 3).toFixed(1)} GB)` : `${status.plan.length} planned actions`;
+	const disk = status.pressure?.disk.map((volume) => `disk ${(volume.freeMb / 1024).toFixed(1)} GB free on ${volume.volume}`).join(", ");
+	return `${includeLabel ? `Auto maintenance (${status.mode === "report" ? "report only" : "off"}): ` : ""}${at ? `${at}: ` : ""}${status.lastPass ? summary : "no pass has run yet"}${disk ? `; ${disk}` : ""}${status.running ? "; running" : ""}${status.lastPass?.blocked.length ? `; ${status.lastPass.blocked.join("; ")}` : ""}${status.invalid ? `; invalid: ${status.invalid}` : ""}${status.claim ? `; unresolved claim: ${status.claim.unresolved}; ${status.claim.removeCommand}` : ""}`;
+}
+function maintenanceLines(status) {
+	const line = maintenanceLine(status);
+	return line === null ? [] : [line];
+}
+//#endregion
+export { maintenanceLines as n, maintenanceStatus as r, maintenanceLine as t };

package/dist/stdout-reader-C8yjre1x.mjs

@@ -0,0 +1,23 @@
+import { fstatSync } from "node:fs";
+//#region src/stdout-reader.ts
+const READER_CHECK_MS = 2e3;
+/**
+* Calls `onGone` once the process reading stdout is gone, for a streaming command that can stay quiet for a long
+* time. Returns a function that stops watching.
+*/
+function watchStdoutReader(onGone) {
+	const parent = process.ppid;
+	const stdout = fstatSync(1);
+	const linuxPipe = process.platform === "linux" && (stdout.isFIFO() || stdout.isSocket());
+	const timer = setInterval(() => {
+		if (linuxPipe && process.ppid !== parent) onGone();
+		else process.stdout.write("");
+	}, READER_CHECK_MS);
+	process.stdout.on("error", onGone);
+	return () => {
+		clearInterval(timer);
+		process.stdout.off("error", onGone);
+	};
+}
+//#endregion
+export { watchStdoutReader as t };

package/dist/stim-desktop-Cnz8CPnl.mjs

@@ -0,0 +1,63 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+//#region src/devices/stim-desktop.ts
+const LAUNCH_SERVICES_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier('dev.stim.desktop'); url.isNil() ? '' : url.path.js`;
+const SCHEME_HANDLER_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL($.NSURL.URLWithString('stim-desktop://workspace')); url.isNil() ? '' : url.path.js`;
+const STIM_DESKTOP_INSTALLED = "Stim Desktop installed";
+/**
+* macOS `open` passes its environment to an app it launches, so Stim Desktop
+* started by a command run under a scoped `STIM_HOME` would serve that home.
+*/
+const STIM_DESKTOP_OPEN_OPTIONS = {
+	timeoutMs: 5e3,
+	killSignal: "SIGKILL",
+	omitEnv: ["STIM_HOME"]
+};
+/** Stim Desktop sets `STIM_DESKTOP_APP` to its bundle path for every command it runs; a non-empty value means Desktop is installed. */
+function stimDesktopInstalled(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return launchServicesFinds(LAUNCH_SERVICES_LOOKUP);
+}
+function launchServicesFinds(script) {
+	return Boolean(getExecutor().runFileQuiet("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		script
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}));
+}
+function stimDesktopHandlesLinks(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return launchServicesFinds(SCHEME_HANDLER_LOOKUP);
+}
+/**
+* The links that open this workspace for a human, or undefined when no app on this Mac handles
+* `stim-desktop://`. `target` names the device Stim Desktop focuses when the user opens the workspace.
+*/
+function workspaceLinks(root, target, handlesLinks = stimDesktopHandlesLinks) {
+	if (!handlesLinks()) return void 0;
+	let desktop = `stim-desktop://workspace?path=${linkParam(root)}`;
+	if (target) desktop += `&platform=${target.platform}`;
+	if (target?.slot && target.slot !== "default") desktop += `&slot=${linkParam(target.slot)}`;
+	return { desktop };
+}
+const linkParam = (value) => encodeURIComponent(value).replaceAll("%2F", "/");
+function workspaceLinkLine(links) {
+	return `Open in Stim Desktop: ${links.desktop}`;
+}
+function settingDefault(setting, desktopInstalled = stimDesktopInstalled) {
+	if (setting.desktopDefault !== void 0 && desktopInstalled()) return {
+		value: setting.desktopDefault,
+		reason: STIM_DESKTOP_INSTALLED
+	};
+	return {
+		value: setting.default,
+		reason: null
+	};
+}
+//#endregion
+export { workspaceLinks as a, workspaceLinkLine as i, settingDefault as n, stimDesktopInstalled as r, STIM_DESKTOP_OPEN_OPTIONS as t };

package/dist/stim-footprint.swift

@@ -0,0 +1,32 @@
+// Prints "<pid> <bytes>" for each pid, the pid's physical footprint: the value Activity Monitor's Memory column and
+// top's MEM column show. With no arguments it reads every pid proc_listallpids(3) returns.
+//
+// The footprint comes from proc_pid_rusage(pid, RUSAGE_INFO_V4, ...) in <libproc.h>, field ri_phys_footprint of
+// struct rusage_info_v4 in <sys/resource.h> (macOS 10.14+). The call fails with EPERM for another user's process
+// unless the caller is root, and with ESRCH for a pid that has exited; those pids are left out of the output.
+
+import Darwin
+
+func allPids() -> [pid_t] {
+  var capacity = Int(proc_listallpids(nil, 0)) + 64
+  while true {
+    var pids = [pid_t](repeating: 0, count: capacity)
+    let count = pids.withUnsafeMutableBytes { proc_listallpids($0.baseAddress, Int32($0.count)) }
+    if count < 0 { return [] }
+    if Int(count) < capacity { return Array(pids.prefix(Int(count))) }
+    capacity *= 2
+  }
+}
+
+let arguments = CommandLine.arguments.dropFirst()
+let pids = arguments.isEmpty ? allPids() : arguments.compactMap { pid_t($0) }
+var output = ""
+output.reserveCapacity(pids.count * 20)
+var info = rusage_info_v4()
+for pid in pids where pid > 0 {
+  let status = withUnsafeMutablePointer(to: &info) {
+    $0.withMemoryRebound(to: rusage_info_t?.self, capacity: 1) { proc_pid_rusage(pid, RUSAGE_INFO_V4, $0) }
+  }
+  if status == 0 { output += "\(pid) \(info.ri_phys_footprint)\n" }
+}
+fputs(output, stdout)

package/dist/{stim-installations-CINXy_su.mjs → stim-installations-QMEI32v1.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, join, resolve } from "node:path";
 //#region src/diagnostics/stim-installations.ts

package/dist/stop-B0Yxtmiy.mjs

@@ -0,0 +1,48 @@
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { c as writeWorkspaceState, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { a as requiredMacosRecord, i as macosRuntimeClaim } from "./state-3DwSQIBK.mjs";
+import { n as stopHostedMacos } from "./hosted-macos-BSZyIb3y.mjs";
+import { readMacosRecord } from "@stim-cli/core/state";
+//#region src/macos/stop.ts
+async function stopProcess(record) {
+	if (!record) return;
+	for (const signal of ["SIGTERM", "SIGKILL"]) {
+		const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
+		if (identity === "gone" || identity === "different") return;
+		if (identity !== "same") throw Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS owner pid ${record.pid}; no signal was sent.`), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+		process.kill(record.pid, signal);
+		if (await (0, process_identity_exports.waitForProcessExit)(record, 5e3)) return;
+	}
+	throw new Error(`Owned macOS process ${record.pid} did not exit.`);
+}
+async function stopMacosAppHeld(root) {
+	const record = requiredMacosRecord(root);
+	if (!record) return false;
+	await stopProcess(record.supervisor);
+	await stopProcess(readMacosRecord(root)?.app ?? record.app);
+	const claims = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
+	if (claims.unresolved.length || claims.live.length) throw Object.assign(/* @__PURE__ */ new Error("The macOS runtime claim cannot be released; inspect its recorded owner before cleanup."), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+	return true;
+}
+/** Stops the workspace's app here, or its session on the hosting Mac, which must confirm the session stopped. */
+function stopMacosApp(root) {
+	const stop = async () => {
+		const record = requiredMacosRecord(root);
+		if (!record?.host) return stopMacosAppHeld(root);
+		await stopHostedMacos(root, record.host);
+		const { host: _host, hostLaunched: _launched, ...stopped } = record;
+		writeWorkspaceState(root, { macos: {
+			...stopped,
+			supervisor: void 0
+		} });
+		return true;
+	};
+	return withWorkspaceProcessLock(workspaceDir(root), "macos-launch", stop, {
+		external: true,
+		waitMs: 0,
+		ownerPurpose: "stop macOS app"
+	});
+}
+//#endregion
+export { stopMacosAppHeld as n, stopMacosApp as t };

package/dist/{stop-BzreOWJp.mjs → stop-Bffozsac.mjs}

@@ -1,23 +1,31 @@
-import { A as ownership_claim_exports, B as deviceSlotPlatforms, E as withConfigLock, G as validateDeviceSlot, H as parseDeviceSlotOption, O as process_identity_exports, T as upsertProject, U as projectDeviceSlots, V as parseDeviceSlotKey, o as clearSupervisor, p as getProject } from "./config-lvc7d3C2.mjs";
-import { a as pidExists, b as writeWorkspaceState, c as resolveProjectMetro, h as readWorkspaceState, k as workspaceDir, l as signalProcessTree, m as clearWorkspaceStateKeys, n as killMetroTree, v as withWorkspaceStateLock } from "./metro-CcEo8Fl8.mjs";
-import { i as findCommandWorkspace } from "./project-CWlvEaeN.mjs";
-import { a as clearRemoteSession, c as readMetroTunnel, i as clearManagedMetroTunnel, o as clearWorkspaceLaunches, s as clearWorkspaceSupervisor, u as readRemoteSession } from "./state-DHqvsbqC.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-Blg8IxOh.mjs";
-import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-DVcpw6eE.mjs";
-import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-5c3WrVRm.mjs";
-import { C as teardownOwnedIosSim, S as teardownOwnedBrowser, a as logVanishedSupervisor, l as withdrawDevServerStopRequest, p as stopTunnel, s as requestDevServerStop, u as resolveSupervisorTarget, x as teardownOwnedAvd } from "./stop-cause-hjGBOZTG.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-DyYDF5ww.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-CcR6o6lI.mjs";
-import { _ as describeNativeRunHolder, b as requestNativeRunCancel, f as NATIVE_RUN_LOCK, g as decideStopAction, h as clearNativeRunCancel, i as endRecordedSession, p as NATIVE_RUN_WAIT_MS, v as nativeRunHolder, y as nativeRunWaitNotice } from "./device-remote-D87zEzaq.mjs";
+import { B as parseDeviceSlotKey, D as withConfigLock$1, E as upsertProject, H as projectDeviceSlots, V as parseDeviceSlotOption, W as validateDeviceSlot, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-DnJMdEY-.mjs";
+import { a as findCommandWorkspace } from "./project-Du91Ilvc.mjs";
+import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-BeK1ZPz1.mjs";
+import { c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-D-hLqx1b.mjs";
+import { a as clearRemoteSession, c as readMetroTunnel, i as clearManagedMetroTunnel, o as clearWorkspaceLaunches, s as clearWorkspaceSupervisor, u as readRemoteSession } from "./state-DcW6vOd_.mjs";
+import { a as teardownOwnedBrowser, i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-CL6vDs2Y.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { i as stopTunnel, t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { a as logVanishedSupervisor, l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-CidxIqup.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-DiA16AsN.mjs";
+import { t as stopMacosApp } from "./stop-B0Yxtmiy.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-C8-V13XN.mjs";
+import { i as endRecordedSession } from "./device-remote-D5WVWqOq.mjs";
+import { a as decideStopAction, c as nativeRunWaitNotice, i as clearNativeRunCancel, l as requestNativeRunCancel, n as NATIVE_RUN_WAIT_MS, o as describeNativeRunHolder, s as nativeRunHolder, t as NATIVE_RUN_LOCK } from "./native-run-NaBrRFtQ.mjs";
+import { r as stopHostedIos } from "./hosted-ios-CIWelIqf.mjs";
+import { hostedIosRecords, parseHostedIosPlacement } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/stop.ts
 const DEFAULT_WAIT_MS = 1e4;
 function readSupervisorState(root) {
-	const sup = readWorkspaceState(root)?.supervisor;
+	const sup = readWorkspaceState$1(root)?.supervisor;
 	return sup && typeof sup === "object" ? sup : null;
 }
 function readCollectorState(root) {
-	const collectors = readWorkspaceState(root)?.collectors;
+	const collectors = readWorkspaceState$1(root)?.collectors;
 	return collectors && typeof collectors === "object" ? collectors : {};
 }
 function clearSupervisorState(root, expected) {
@@ -29,7 +37,7 @@ function clearSupervisorState(root, expected) {
 }
 function clearCollectorState(root, expected) {
 	return withWorkspaceStateLock(root, () => {
-		const current = { ...readWorkspaceState(root)?.collectors };
+		const current = { ...readWorkspaceState$1(root)?.collectors };
 		if (expected === void 0) {
 			clearWorkspaceStateKeys(root, ["collectors"]);
 			return true;
@@ -150,6 +158,8 @@ async function runStop(options) {
 		},
 		clearRegistration: async () => true,
 		teardownBrowser: null,
+		stopMacos: false,
+		hostedSlot: slot,
 		releaseLeases: (projectRoot) => releaseWorkspaceLeases(projectRoot, { slot })
 	});
 	result.outcomes.port = {
@@ -208,7 +218,52 @@ async function stopBrowserOnly({ root, project = void 0, teardownBrowser = (proj
 		summary: summarize(root, outcomes, ok)
 	};
 }
-async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+async function stopWorkspaceHostedIos(root, slot, report, failed) {
+	const devices = {};
+	let anyFailed = false;
+	for (const [name, record] of Object.entries(hostedIosRecords(readWorkspaceState$1(root)))) {
+		if (slot !== void 0 && name !== slot) continue;
+		const placement = parseHostedIosPlacement(record);
+		const label = placement ? `${placement.device?.name ?? "iOS simulator"} on ${placement.machine}` : `hosted iOS simulator for slot ${name}`;
+		try {
+			await stopHostedIos(root, name);
+			devices[`ios:host:${name}`] = {
+				status: "shut-down",
+				label
+			};
+			report(chalk.dim(phaseLine("device", `stopped ${label}`)));
+		} catch (error) {
+			const reason = error.message;
+			devices[`ios:host:${name}`] = {
+				status: "failed",
+				label,
+				reason
+			};
+			report(chalk.red(phaseLine("device", reason)));
+			failed();
+			anyFailed = true;
+		}
+	}
+	return {
+		devices,
+		failed: anyFailed
+	};
+}
+async function stopWorkspaceMacos(root, failed, enabled) {
+	if (enabled === false || readWorkspaceState$1(root)?.macos === void 0) return void 0;
+	try {
+		await stopMacosApp(root);
+		return { status: "stopped" };
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		failed(reason);
+		return {
+			status: "failed",
+			reason
+		};
+	}
+}
+async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, hostedSlot, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
 	const proj = project === void 0 ? getProject(root) : project;
 	const sup = state === void 0 ? readSupervisorState(root) : state;
 	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
@@ -365,6 +420,14 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	}
 	outcomes.device.web = await closeBrowser(root, teardownBrowser, report);
 	if (outcomes.device.web && outcomes.device.web.status !== "shut-down") ok = false;
+	outcomes.macos = await stopWorkspaceMacos(root, (reason) => {
+		ok = false;
+		report(reason);
+	}, stopMacos);
+	const hosted = await stopWorkspaceHostedIos(root, hostedSlot, report, () => {
+		ok = false;
+	});
+	Object.assign(outcomes.device, hosted.devices);
 	const remote = remoteDevice === void 0 ? readRemoteSession(root) : remoteDevice;
 	const sessionId = typeof remote?.sessionId === "string" ? remote.sessionId : null;
 	if (sessionId) {
@@ -740,6 +803,8 @@ async function closeBrowser(root, teardownBrowser, report) {
 }
 function summarize(root, outcomes, ok) {
 	const parts = [];
+	if (outcomes.macos?.status === "stopped") parts.push("macOS app stopped");
+	if (outcomes.macos?.status === "failed") parts.push("macOS app could not be stopped");
 	if (outcomes.supervisor.status === "stopped") parts.push(`supervisor pid ${outcomes.supervisor.pid} stopped`);
 	if (outcomes.supervisor.status === "already-stopped") parts.push("supervisor already stopped");
 	if (outcomes.supervisor.status === "timeout") parts.push(`supervisor pid ${outcomes.supervisor.pid} still running`);
@@ -769,7 +834,7 @@ function summarize(root, outcomes, ok) {
 	return `${ok ? "Stopped" : "Stopped with problems"}: ${what} (${root})`;
 }
 function defaultFreePort(root, port) {
-	return withConfigLock(() => {
+	return withConfigLock$1(() => {
 		const current = getProject(root);
 		if (!current) return true;
 		if (current.supervisor || current.metroPort !== port) return false;
@@ -810,10 +875,12 @@ function recordedDeviceSlots(root) {
 		const parsed = parseDeviceSlotKey(key);
 		if (parsed) slots.add(parsed.slot);
 	}
+	for (const slot of Object.keys(hostedIosRecords(readWorkspaceState$1(root)))) slots.add(slot);
 	return [...slots].toSorted();
 }
 function workspaceDeviceSlots(root) {
 	const slots = projectDeviceSlots(getProject(root)).filter(({ platforms }) => Object.values(platforms).some(Boolean)).map(({ slot }) => slot);
+	for (const slot of Object.keys(hostedIosRecords(readWorkspaceState$1(root)))) if (!slots.includes(slot)) slots.push(slot);
 	if (typeof readRemoteSession(root)?.sessionId === "string" && !slots.includes("default")) slots.push("default");
 	return slots;
 }

package/dist/{stop-BWIF_6BK.mjs → stop-Dt_dM16A.mjs}

@@ -1,3 +1,3 @@
-import { u as resolveSupervisorTarget } from "./stop-cause-hjGBOZTG.mjs";
-import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BzreOWJp.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-Bffozsac.mjs";
 export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop, stopWorkspaceNow };

package/dist/stop-cause-CidxIqup.mjs

@@ -0,0 +1,97 @@
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { c as writeWorkspaceState, t as clearWorkspaceStateKey, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { join } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { DEV_SERVER_STOP_REQUEST_KEY, readDevServerStop, readDevServerStopRequest } from "@stim-cli/core/state";
+//#region src/supervisor/stop-cause.ts
+function requestDevServerStop(root, processToken, requester) {
+	if (!processToken) return;
+	try {
+		writeWorkspaceState(root, { [DEV_SERVER_STOP_REQUEST_KEY]: {
+			processToken,
+			by: requester.by,
+			pid: process.pid,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			...requester.workspace ? { workspace: requester.workspace } : {}
+		} });
+	} catch {}
+}
+function withdrawDevServerStopRequest(root, processToken) {
+	if (!processToken) return;
+	try {
+		clearWorkspaceStateKey(root, DEV_SERVER_STOP_REQUEST_KEY, (value) => {
+			return readDevServerStopRequest({ [DEV_SERVER_STOP_REQUEST_KEY]: value })?.processToken === processToken;
+		});
+	} catch {}
+}
+function devServerStopRecord(trigger, request, at) {
+	if (request) return {
+		reason: "requested",
+		at,
+		by: request.by,
+		byPid: request.pid,
+		...request.workspace ? { byWorkspace: request.workspace } : {}
+	};
+	return trigger.kind === "signal" ? {
+		reason: "signal",
+		at,
+		signal: trigger.signal
+	} : {
+		reason: "server-exited",
+		at,
+		mode: trigger.mode,
+		code: trigger.code,
+		signal: trigger.signal
+	};
+}
+function describeDevServerStop(record) {
+	if (record.reason === "idle") return `idle for ${record.idleMinutes} minutes (metro.idleStopMinutes)`;
+	if (record.reason === "requested") return `stop requested by ${record.by} (pid ${record.byPid}${record.byWorkspace ? ` in ${record.byWorkspace}` : ""})`;
+	if (record.reason === "signal") return `received ${record.signal} with no Stim stop request recorded, so it likely came from outside Stim`;
+	const detail = record.signal ? `signal ${record.signal}` : `exit code ${record.code ?? "unknown"}`;
+	const expoSignal = record.mode === "expo-child" && record.code === 0 ? "; Expo CLI also exits 0 on SIGTERM, and no Stim stop request was recorded" : "";
+	return `the ${record.mode} dev server exited unexpectedly (${detail})${expoSignal}`;
+}
+function devServerStopLevel(record) {
+	if (record.reason === "server-exited") return "error";
+	return record.reason === "signal" ? "warn" : "info";
+}
+/** The log line for a recorded supervisor whose process is proven gone, or null while it may still run. */
+function vanishedSupervisorMessage(record) {
+	if (!record || typeof record.pid !== "number") return null;
+	const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
+	if (identity !== "gone" && identity !== "different") return null;
+	const started = typeof record.startedAt === "string" ? ` (started ${record.startedAt})` : "";
+	return `supervisor pid ${record.pid}${started} ${VANISHED}`;
+}
+const VANISHED = "is gone and recorded no cause: usually SIGKILL, a crash or a machine restart";
+function logVanishedSupervisor(root, record) {
+	const msg = vanishedSupervisorMessage(record);
+	if (!msg) return;
+	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	writer.write({
+		src: "metro",
+		level: "warn",
+		event: "supervisor_vanished",
+		msg
+	});
+	writer.close();
+}
+/** The recorded stop, else a vanished supervisor when status proved the recorded one gone. */
+function metroLastStop(state, supervisor) {
+	const recorded = readDevServerStop(state);
+	if (recorded) return recorded;
+	if (supervisor?.status !== "stale" || typeof supervisor.pid !== "number") return null;
+	const startedAt = typeof supervisor.startedAt === "string" ? supervisor.startedAt : null;
+	return {
+		reason: "vanished",
+		pid: supervisor.pid,
+		startedAt
+	};
+}
+function describeMetroLastStop(stop) {
+	return stop.reason === "vanished" ? `supervisor pid ${stop.pid} ${VANISHED}` : describeDevServerStop(stop);
+}
+//#endregion
+export { logVanishedSupervisor as a, vanishedSupervisorMessage as c, devServerStopRecord as i, withdrawDevServerStopRequest as l, describeMetroLastStop as n, metroLastStop as o, devServerStopLevel as r, requestDevServerStop as s, describeDevServerStop as t };

package/dist/supervisor-run.d.mts

@@ -1,19 +1,43 @@
 import { t as NdjsonWriter } from "./ndjson-Du3j0AQ9.mjs";
-import { DevServerStopRecord } from "@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,8 +90,9 @@ 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, stop?: DevServerStopRecord) => Promise<void>;
@@ -68,4 +100,4 @@ declare function runSupervisor({ root, port, tunnel, resetCache, idleStopMinutes
 } | 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 };