stim 1.12.0 → 1.13.0

package/dist/{status-DI9Tjo7T.mjs → status-TJlL0HWo.mjs}

@@ -1,67 +1,81 @@
-import { I as volumeRootFor, U as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir } from "./config-0jCcMM0E.mjs";
+import { I as volumeRootFor, U as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir, z as deviceSlotKey } from "./config-0jCcMM0E.mjs";
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
 import { a as parseNdjsonLine } from "./ndjson-CDY9IkVC.mjs";
-import { A as workspaceLogErrorIndex, a as processCwd, j as workspaceLogsDir, l as isMetroRunning, m as readWorkspaceState$1, n as listeningPids, o as processCwds, r as listeningPidsByPort, s as resolveProjectMetro } from "./metro-Dzo30hvJ.mjs";
+import { M as workspaceLogsDir, c as resolveProjectMetro, h as readWorkspaceState$1, i as listeningPidsByPort, j as workspaceLogErrorIndex, o as processCwd, r as listeningPids, s as processCwds, u as isMetroRunning } from "./metro-BPeY1YMh.mjs";
 import { c as gitCommonDirOnDisk, p as linkedWorktreesOnDisk, s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
-import { i as findProjectRoot, s as projectShortcut } from "./project-B8rbutVC.mjs";
-import { f as readWorkspaceLaunches, u as readRemoteSession } from "./state-DcDgzfu3.mjs";
-import { i as formatDuration } from "./command-output-BWCj5Vh-.mjs";
-import { i as listLeaseFiles } from "./device-lease-B9LAXIUH.mjs";
-import { n as createActivityReader } from "./activity-CCZJs__P.mjs";
-import { L as ownedAvdSerialResolver, N as ownedAvdDeviceProfile, u as androidToolPath } from "./android-75Sk2rIR.mjs";
-import { b as readParked, h as POOL_SETTING_REMEDY, t as resolveSupervisorTarget, y as parkedMaxSetting } from "./ownership-B8d4kXBx.mjs";
-import { _ as parseSimctlList, u as listAllIosSimsAsync } from "./ios-CZWOHTTc.mjs";
-import { a as buildStatusLine, i as buildReport, r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-h60GPV27.mjs";
-import { T as readEasSessionLedger$1, w as easMachineStateRoot$1 } from "./device-remote-C0_o-tJH.mjs";
-import { a as deviceLeaseStates, d as poolLine, f as remoteDeviceLine, h as unprovisionedWorktrees, i as deviceLeaseLines, l as gitSummaryText, m as tightVolumes, n as activityLabel, o as diskLine, p as remoteDeviceState, r as capacity, s as environmentState, u as parseDfFree } from "./status-BUASYyy_.mjs";
+import { l as projectShortcut, o as findServerWorkspace, r as detectIsExpo } from "./project-DGeclhvO.mjs";
+import { f as readWorkspaceLaunches, u as readRemoteSession } from "./state-DwAU2_-D.mjs";
+import { i as formatDuration } from "./command-output-BIL7rlX7.mjs";
+import { i as listLeaseFiles } from "./device-lease-CL9dZf73.mjs";
+import { n as createActivityReader, r as createDeviceProcessTables } from "./activity-DfVKZTEB.mjs";
+import { P as ownedAvdDeviceProfile, R as ownedAvdSerialResolver, ct as parkedMaxSetting, lt as readParked, rt as POOL_SETTING_REMEDY, u as androidToolPath } from "./android-qx_31wJo.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
+import { a as readWebRecord, l as webFacts } from "./state-l1pYwOre.mjs";
+import { _ as parseSimctlList, u as listAllIosSimsAsync } from "./ios-CmEzZiOj.mjs";
+import { a as buildStatusLine, i as buildReport, r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-l7d-X-ZP.mjs";
+import { T as readEasSessionLedger$1, w as easMachineStateRoot$1 } from "./device-remote-DT9ngZiD.mjs";
+import { _ as withWebFacts, a as deviceLeaseStates, d as poolLine, f as remoteDeviceLine, g as unprovisionedWorktrees, h as tightVolumes, i as deviceLeaseLines, l as gitSummaryText, m as statusActivity, n as activityLabel, o as diskLine, p as remoteDeviceState, r as capacity, s as environmentState, u as parseDfFree } from "./status-sszP4XKU.mjs";
 import { a as statsProjectKey, r as readStats } from "./stats-D8rUTPHd.mjs";
 import { n as mergeState } from "./merge-state-ytFQCeh4.mjs";
-import { i as readSupervisorState } from "./stop-Bn6v-GvS.mjs";
-import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, watch, writeFileSync } from "node:fs";
+import { i as readSupervisorState } from "./stop-BZ2qMiBP.mjs";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { closeSync as closeSync$1, existsSync as existsSync$1, fstatSync as fstatSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, renameSync as renameSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { basename, dirname, join } from "path";
 import { rotatedLogPath } from "@stim-cli/core";
-import { ERROR_SOURCES, gitMergeCacheDir, logFiles, queryLogs, readIdleStop, readLastBuilds, recordMatches } from "@stim-cli/core/state";
-import { join as join$1, posix } from "node:path";
+import { ERROR_SOURCES, MACHINE_OWNER_KINDS, gitMergeCacheDir, logFiles, queryLogs, readBuildHistory, readIdleStop, readLastBuilds, recordMatches, withStateReadCache } from "@stim-cli/core/state";
+import { join as join$1, posix, resolve as resolve$1 } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir, totalmem } from "os";
 import chalk from "chalk";
 //#region src/status-watch.ts
 const WATCH_FALLBACK_MS = 3e4;
-const WATCH_SIMCTL_INTERVAL_MS = 2e3;
+const WATCH_LIGHT_INTERVAL_MS = 15e3;
+const WATCH_SIMCTL_INTERVAL_MS = 5e3;
 const ADB_RESTART_MIN_MS = 1e3;
 const ADB_RESTART_MAX_MS = 6e4;
 const SIMCTL_TIMEOUT_MS = 1e4;
 /**
-* Coalesces change signals into refreshes: a burst of triggers runs `run` once
-* after `debounceMs` of quiet, at most one run is in flight, and a trigger that
-* arrives during a run causes exactly one more run after it.
+* Coalesces change signals into refreshes: a burst of full triggers runs `run('full')` once after `debounceMs` of
+* quiet, at most one run is in flight, and a trigger that arrives during a run causes exactly one more run after it.
+* A `light` trigger runs `run('light')` no sooner than `debounceMs` from the trigger and `lightIntervalMs` from the
+* start of the previous run, unless a queued full run covers it; later light triggers do not postpone it.
 */
-function createRefreshScheduler({ debounceMs, run }) {
+function createRefreshScheduler({ debounceMs, lightIntervalMs = 0, run }) {
 	let timer = null;
+	let queued = "full";
 	let running = false;
-	let pending = false;
+	let pending = null;
 	let stopped = false;
+	let lastRunAt = -Infinity;
 	const fire = async () => {
 		timer = null;
 		running = true;
+		lastRunAt = Date.now();
 		try {
-			await run();
+			await run(queued);
 		} finally {
 			running = false;
 			if (pending) {
-				pending = false;
-				trigger();
+				const next = pending;
+				pending = null;
+				trigger(next);
 			}
 		}
 	};
-	function trigger(delayMs = debounceMs) {
+	function trigger(kind = "full", delayMs = debounceMs) {
 		if (stopped) return;
 		if (running) {
-			pending = true;
+			pending = pending === "full" ? "full" : kind;
+			return;
+		}
+		if (kind === "light") {
+			if (timer) return;
+			queued = "light";
+			timer = setTimeout(() => void fire(), Math.max(delayMs, lastRunAt + lightIntervalMs - Date.now()));
 			return;
 		}
 		if (timer) clearTimeout(timer);
+		queued = "full";
 		timer = setTimeout(() => void fire(), delayMs);
 	}
 	return {
@@ -74,17 +88,19 @@ function createRefreshScheduler({ debounceMs, run }) {
 	};
 }
 /**
-* Whether a change to `name` in a watched `$STIM_HOME` directory can change
-* the status payload. A null name means the platform did not report one.
+* Which refresh a change to `name` in a watched `$STIM_HOME` directory needs: `light` for a log append, which can
+* change only the log-derived fields, `full` for anything else that can change the payload, null for none. A null
+* name means the platform did not report one.
 */
-function changeAffectsStatus(dir, name) {
-	if (name === null) return true;
-	if (name.includes(".lock")) return false;
+function statusChange(dir, name) {
+	if (name?.includes(".lock")) return null;
+	if (dir === "logs") return "light";
+	if (name === null) return "full";
 	switch (dir) {
-		case "home": return name.startsWith("config.json") || name === "workspaces" || name === "device-locks";
-		case "workspace": return name.startsWith("state.json") || name === "logs";
-		case "eas": return name.startsWith("sessions.json");
-		default: return true;
+		case "home": return name.startsWith("config.json") || name === "workspaces" || name === "device-locks" ? "full" : null;
+		case "workspace": return name.startsWith("state.json") || name === "logs" ? "full" : null;
+		case "eas": return name.startsWith("sessions.json") ? "full" : null;
+		default: return "full";
 	}
 }
 /** A stable summary of every simulator's state, or null when the listing is unreadable. */
@@ -132,9 +148,13 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			if (watchers.has(dir)) continue;
 			try {
 				const watcher = watch(dir, (_event, name) => {
-					if (!changeAffectsStatus(kind, name === null ? null : String(name))) return;
-					if (kind === "home" || kind === "workspaces" || kind === "workspace") reconcile();
-					onChange();
+					const change = statusChange(kind, name === null ? null : String(name));
+					if (!change) return;
+					if (kind === "home" || kind === "workspaces" || kind === "workspace") {
+						listingStaleBefore = Date.now();
+						reconcile();
+					}
+					onChange(change);
 				});
 				watcher.on("error", () => {
 					watcher.close();
@@ -144,13 +164,16 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			} catch {}
 		}
 	};
-	const adb = trackAdbDevices(onChange);
+	const adb = trackAdbDevices(() => onChange("full"));
 	let simctl = null;
+	let listing = null;
+	let listingStaleBefore = 0;
 	let simTimer = null;
 	if (platform === "darwin") {
 		let last = null;
 		const check = () => {
 			if (simctl || stopped) return;
+			const startedAt = Date.now();
 			let out = "";
 			const child = getExecutor().spawn("xcrun", [
 				"simctl",
@@ -175,7 +198,11 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 				simctl = null;
 				const signature = simulatorSignature(out);
 				if (signature === null || stopped) return;
-				if (last !== null && signature !== last) onChange();
+				listing = {
+					at: startedAt,
+					json: out
+				};
+				if (last !== null && signature !== last) onChange("full");
 				last = signature;
 			});
 		};
@@ -185,6 +212,7 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 	reconcile();
 	return {
 		reconcile,
+		simulatorListing: () => listing && listing.at > listingStaleBefore && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
 		stop() {
 			stopped = true;
 			for (const watcher of watchers.values()) watcher.close();
@@ -238,7 +266,7 @@ function trackAdbDevices(onChange) {
 }
 //#endregion
 //#region src/diagnostics/error-index.ts
-const INDEX_VERSION = 1;
+const INDEX_VERSION = 3;
 const HEAD_BYTES = 1024;
 const TAIL_BYTES = 256;
 const CHUNK_BYTES = 4194304;
@@ -251,7 +279,7 @@ const CANDIDATE_PATTERNS = [
 const ERROR_CRITERIA = {
 	errorsOnly: true,
 	sources: ERROR_SOURCES,
-	includeNativeCrashes: true
+	includeAppDeviceErrors: true
 };
 /**
 * The number of records `queryLogs({ dir, errorsOnly: true })` returns, without parsing every
@@ -291,8 +319,9 @@ function summarize(path, known) {
 		return null;
 	}
 	try {
-		const { dev, ino, size } = fstatSync$1(fd);
-		const key = `${dev}:${ino}`;
+		const stat = fstatSync$1(fd, { bigint: true });
+		const key = `${stat.dev}:${stat.ino}`;
+		const size = Number(stat.size);
 		const cached = known[key];
 		const base = cached && stillExtends(fd, cached, size) ? cached : null;
 		const start = base ?? {
@@ -370,12 +399,17 @@ function collect(record, markers, errors) {
 	const ts = typeof record.ts === "number" && Number.isFinite(record.ts) ? record.ts : null;
 	if (record.marker === true && ts !== null) {
 		const metro = record.src === "metro";
+		const web = !metro && record.platform === "web";
 		const slot = record.slot ?? "default";
-		const key = metro ? "metro" : JSON.stringify(["launch", slot]);
+		const key = metro ? "metro" : web ? "web" : JSON.stringify(["launch", slot]);
 		if ((markers[key]?.ts ?? -Infinity) < ts) markers[key] = metro ? {
 			src: "metro",
 			marker: true,
 			ts
+		} : web ? {
+			platform: "web",
+			marker: true,
+			ts
 		} : {
 			marker: true,
 			ts,
@@ -386,6 +420,7 @@ function collect(record, markers, errors) {
 		src: record.src,
 		level: record.level,
 		event: record.event,
+		platform: record.platform,
 		ts: ts ?? void 0,
 		slot: record.slot
 	});
@@ -413,6 +448,7 @@ function writeIndex(file, index) {
 //#region src/workspace/git-summary.ts
 const GIT_TIMEOUT_MS = 3e3;
 const MERGE_BUDGET_MS = 250;
+const MERGE_TIMEOUT_BACKOFF_MS = 3e5;
 const ORIGIN_PREFIX = "refs/remotes/origin/";
 /** Counts the entries of `git status --porcelain=v2 --branch` output. `head` is null on an unborn branch. */
 function parseGitStatus(text) {
@@ -508,11 +544,33 @@ function mergedInto(path, head, target, budget) {
 	const targetKey = `${target.ref} ${target.sha}`;
 	const cached = readMergeCache(path);
 	const known = cached?.head === head ? cached : null;
-	if (known?.target === targetKey) return known.mergedInto;
-	if (budget.deadline !== void 0 && Date.now() > budget.deadline) return known?.target.startsWith(`${target.ref} `) ? known.mergedInto : null;
+	if (known?.target === targetKey) return {
+		into: known.mergedInto,
+		deferred: false
+	};
+	const standIn = known?.target.startsWith(`${target.ref} `) ? known.mergedInto : null;
+	const timeoutKey = `${head} ${targetKey}`;
+	const timedOut = mergeTimeouts.get(path);
+	if (timedOut?.key === timeoutKey && Date.now() - timedOut.at < MERGE_TIMEOUT_BACKOFF_MS) return {
+		into: standIn,
+		deferred: false
+	};
+	if (budget.deadline !== void 0 && Date.now() > budget.deadline) return {
+		into: standIn,
+		deferred: true
+	};
 	budget.deadline ??= Date.now() + MERGE_BUDGET_MS;
 	const state = mergeState(path, target, { timeoutMs: GIT_TIMEOUT_MS });
-	if (!state.merged && state.timedOut) return null;
+	if (!state.merged && state.timedOut) {
+		mergeTimeouts.set(path, {
+			key: timeoutKey,
+			at: Date.now()
+		});
+		return {
+			into: standIn,
+			deferred: false
+		};
+	}
 	const verdict = state.merged ? state.into : null;
 	writeMergeCache({
 		path,
@@ -520,29 +578,97 @@ function mergedInto(path, head, target, budget) {
 		target: targetKey,
 		mergedInto: verdict
 	});
-	return verdict;
+	return {
+		into: verdict,
+		deferred: false
+	};
 }
+const mergeTimeouts = /* @__PURE__ */ new Map();
 const recent = /* @__PURE__ */ new Map();
+function gitDirsOf(worktree) {
+	try {
+		const dotGit = join$1(worktree, ".git");
+		const pointer = statSync(dotGit).isDirectory() ? null : /^gitdir: (.+)$/m.exec(readFileSync(dotGit, "utf-8"))?.[1]?.trim();
+		const gitDir = pointer ? resolve$1(worktree, pointer) : pointer === null ? dotGit : null;
+		if (!gitDir) return null;
+		try {
+			return {
+				gitDir,
+				commonDir: resolve$1(gitDir, readFileSync(join$1(gitDir, "commondir"), "utf-8").trim())
+			};
+		} catch {
+			return {
+				gitDir,
+				commonDir: gitDir
+			};
+		}
+	} catch {
+		return null;
+	}
+}
+function fileStamp(path) {
+	try {
+		const stat = statSync(path, { bigint: true });
+		return `${stat.ino}:${stat.mtimeNs}:${stat.size}`;
+	} catch {
+		return "-";
+	}
+}
+/**
+* Stamps the git files a summary depends on: the worktree's index, HEAD and reflog, and the common dir's packed refs,
+* last fetch, origin/HEAD, default-branch ref, branch ref and upstream ref. Edits, creations and deletions of files
+* that are not staged touch none of them. `missing` when the worktree has no git dir, such as a deleted worktree git
+* still lists; it is then stamped by its `.git` entry alone.
+*/
+function gitFilesStamp(worktree, refs) {
+	const dirs = gitDirsOf(worktree.path);
+	if (!dirs) return {
+		stamp: fileStamp(join$1(worktree.path, ".git")),
+		missing: true
+	};
+	const { gitDir, commonDir } = dirs;
+	return {
+		stamp: [
+			join$1(gitDir, "index"),
+			join$1(gitDir, "HEAD"),
+			join$1(gitDir, "logs", "HEAD"),
+			join$1(commonDir, "packed-refs"),
+			join$1(commonDir, "FETCH_HEAD"),
+			join$1(commonDir, "refs", "remotes", "origin", "HEAD"),
+			...refs.target ? [join$1(commonDir, refs.target)] : [],
+			...worktree.branch ? [join$1(commonDir, "refs", "heads", worktree.branch)] : [],
+			...refs.upstream ? [join$1(commonDir, "refs", "remotes", refs.upstream), join$1(commonDir, "refs", "heads", refs.upstream)] : []
+		].map(fileStamp).join(" "),
+		missing: false
+	};
+}
 /**
 * Reads every worktree's git summary in parallel, each git call bounded by a timeout. A worktree `skip` rejects, or
 * one git cannot answer in time, maps to null. After every read, merge verdicts missing from the cache are judged one
 * at a time; no new judgement starts 250 ms after the first, and a verdict for the same HEAD judged at an older
-* default-branch commit stands in, because a merged branch stays merged. With `maxAgeMs`, a summary read that
-* recently in this process is reused.
+* default-branch commit stands in, because a merged branch stays merged. A judgement that timed out is not retried
+* for the same HEAD and target for five minutes. With `maxAgeMs`, a summary made that recently in this process is
+* reused while the git files it depends on are unchanged, so a change that is not staged can take up to `maxAgeMs`
+* to show; so is the null of a worktree whose directory is gone.
 */
 async function readWorktreeGit(worktrees, { skip, maxAgeMs = 0 }) {
 	const now = Date.now();
 	const targets = /* @__PURE__ */ new Map();
 	const reads = await Promise.all(worktrees.map(async (worktree) => {
-		const memo = recent.get(worktree.path);
-		if (memo && now - memo.at < maxAgeMs) return {
-			path: worktree.path,
-			memo: memo.git
-		};
 		if (skip(worktree)) return {
 			path: worktree.path,
 			memo: null
 		};
+		const memo = maxAgeMs > 0 ? recent.get(worktree.path) : void 0;
+		const refs = memo?.refs ?? {
+			upstream: null,
+			target: null
+		};
+		const files = maxAgeMs > 0 ? gitFilesStamp(worktree, refs) : null;
+		if (memo && memo.files !== null && memo.files === files?.stamp && now - memo.at < maxAgeMs) return {
+			path: worktree.path,
+			memo: memo.git
+		};
 		const repository = worktree.repository;
 		if (repository && !targets.has(repository)) targets.set(repository, defaultBranchOf(repository));
 		const [out, target] = await Promise.all([git(worktree.path, [
@@ -554,23 +680,43 @@ async function readWorktreeGit(worktrees, { skip, maxAgeMs = 0 }) {
 		return {
 			path: worktree.path,
 			status: out === null ? null : parseGitStatus(out),
-			target
+			target,
+			files,
+			refs
 		};
 	}));
 	const budget = {};
 	const summaries = /* @__PURE__ */ new Map();
 	for (const read of reads) {
-		if ("memo" in read || !read.status) {
-			summaries.set(read.path, "memo" in read ? read.memo ?? null : null);
+		if ("memo" in read) {
+			summaries.set(read.path, read.memo ?? null);
+			continue;
+		}
+		if (!read.status) {
+			if (read.files?.missing) recent.set(read.path, {
+				at: now,
+				files: read.files.stamp,
+				refs: read.refs,
+				git: null
+			});
+			summaries.set(read.path, null);
 			continue;
 		}
 		const { head, ...counts } = read.status;
+		const merge = head && read.target ? mergedInto(read.path, head, read.target, budget) : null;
 		const summary = {
 			...counts,
-			mergedInto: head && read.target ? mergedInto(read.path, head, read.target, budget) : null
+			mergedInto: merge?.into ?? null
+		};
+		const refs = {
+			upstream: counts.upstream,
+			target: read.target?.ref ?? null
 		};
+		const settled = !merge?.deferred && refs.upstream === read.refs.upstream && refs.target === read.refs.target;
 		recent.set(read.path, {
 			at: now,
+			files: settled ? read.files?.stamp ?? null : null,
+			refs,
 			git: summary
 		});
 		summaries.set(read.path, summary);
@@ -578,25 +724,268 @@ async function readWorktreeGit(worktrees, { skip, maxAgeMs = 0 }) {
 	return summaries;
 }
 //#endregion
+//#region src/devices/app-process.ts
+const bundleIdsByApp = /* @__PURE__ */ new Map();
+function simAppPaths(commands, udid) {
+	const marker = `/Devices/${udid}/data/Containers/Bundle/Application/`;
+	const paths = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		const at = command.indexOf(marker);
+		if (!command.startsWith("/") || at < 0 || /[\s=]\//.test(command.slice(0, at))) continue;
+		const rest = command.slice(at + marker.length);
+		const app = /^[^/]+\/[^/]+\.app\//.exec(rest)?.[0];
+		if (!app || /^[^/\s]*\//.test(rest.slice(app.length))) continue;
+		paths.add(command.slice(0, at + marker.length) + app.slice(0, -1));
+	}
+	return [...paths];
+}
+function androidAppRunning(psOutput, packageName) {
+	return psOutput.split("\n").some((line) => {
+		return /^\s*\d+\s+(\S+)\s*$/.exec(line)?.[1] === packageName;
+	});
+}
+function plistBundleId(appPath) {
+	const cached = bundleIdsByApp.get(appPath);
+	if (cached) return cached;
+	const id = getExecutor().runFileQuiet("plutil", [
+		"-extract",
+		"CFBundleIdentifier",
+		"raw",
+		"-o",
+		"-",
+		join$1(appPath, "Info.plist")
+	], { timeoutMs: 2e3 })?.trim() || null;
+	if (id) bundleIdsByApp.set(appPath, id);
+	return id;
+}
+function createAppProcessReader(tables, bundleIdOf = plistBundleId) {
+	return ({ platform, id, appId }) => {
+		const result = (state) => ({
+			id: appId,
+			state
+		});
+		if (platform === "android") {
+			const output = tables.android(id);
+			if (output === null) return result("unknown");
+			return result(androidAppRunning(output, appId) ? "running" : "stopped");
+		}
+		const host = tables.host();
+		if (host === null) return result("unknown");
+		const ids = simAppPaths(host.map((row) => row.command), id).map(bundleIdOf);
+		if (ids.includes(appId)) return result("running");
+		return result(ids.includes(null) ? "unknown" : "stopped");
+	};
+}
+//#endregion
+//#region src/machine-usage.ts
+const SHARED = [
+	{
+		name: "CoreSimulator services",
+		pattern: /\/CoreSimulator\.framework\/|\/Simulator\.app\/Contents\/MacOS\//
+	},
+	{
+		name: "adb server",
+		pattern: /(^|\/)adb\s.*\bfork-server\b/
+	},
+	{
+		name: "Android emulator services",
+		pattern: /\/emulator\/netsimd(\s|$)/
+	},
+	{
+		name: "Gradle daemon",
+		pattern: /\borg\.gradle\.launcher\.daemon\.bootstrap\.GradleDaemon\b/
+	},
+	{
+		name: "Kotlin daemon",
+		pattern: /\bKotlinCompileDaemon\b/
+	},
+	{
+		name: "Watchman",
+		pattern: /(^|\/)watchman(\s|$)/
+	}
+];
+const SERVER = /(^|[\s/])stim-server(\.mjs)?(\s|$)/;
+const LAUNCHD_SIM = /^launchd_sim\s.*\/Devices\/([^/\s]+)\//;
+const MAX_DEPTH = 64;
+const EMULATOR = /(?:^|\/)(?:qemu-system-[^\s/]+|emulator)(?:\s.*)?\s(?:-avd\s+|@)(\S+)/;
+function emulatorAvd(command) {
+	return EMULATOR.exec(command)?.[1] ?? null;
+}
+function workspaceOwner(kind, env, name, id) {
+	return {
+		kind,
+		name,
+		workspace: env.path,
+		id,
+		owned: true
+	};
+}
+function rank(owner) {
+	return MACHINE_OWNER_KINDS.indexOf(owner.kind);
+}
+/**
+* Attributes every process in `processes` to at most one owner: the owner of its nearest ancestor (itself included)
+* that is a root. Roots are each booted simulator's `launchd_sim`, each emulator launcher and qemu process, and each
+* workspace's verified supervisor and Metro, running build and Chrome. Only a process under none of those falls back
+* to stim-server or a machine-wide service in `SHARED`, so a `simctl` a workspace's log collector runs stays with the
+* workspace. A process with no root ancestor is left out.
+*/
+function attributeMachineUsage({ processes, environments, roots, simNames }) {
+	const owners = /* @__PURE__ */ new Map();
+	const rootOf = /* @__PURE__ */ new Map();
+	const fallbackOf = /* @__PURE__ */ new Map();
+	const claim = (pid, key, owner, into = rootOf) => {
+		if (!owners.has(key)) owners.set(key, owner);
+		into.set(pid, key);
+	};
+	const sims = /* @__PURE__ */ new Map();
+	const emulators = /* @__PURE__ */ new Map();
+	for (const env of environments) for (const device of [{
+		slot: "default",
+		ios: env.ios,
+		android: env.android
+	}, ...env.slots ?? []]) {
+		const slot = device.slot === "default" ? {} : { slot: device.slot };
+		if (device.ios?.state === "Booted") sims.set(device.ios.udid.toUpperCase(), {
+			kind: "simulator",
+			name: device.ios.name ?? device.ios.udid,
+			workspace: env.path,
+			...slot,
+			id: device.ios.udid,
+			owned: device.ios.owned
+		});
+		if (device.android?.name && !device.android.physical && device.android.serial) emulators.set(device.android.name, {
+			kind: "emulator",
+			name: device.android.name,
+			workspace: env.path,
+			...slot,
+			id: device.android.name,
+			owned: device.android.owned
+		});
+	}
+	for (const p of processes) {
+		const shared = SHARED.find(({ pattern }) => pattern.test(p.command));
+		if (shared) {
+			const owner = {
+				kind: "shared",
+				name: shared.name,
+				workspace: null,
+				id: null,
+				owned: false
+			};
+			claim(p.pid, `shared:${shared.name}`, owner, fallbackOf);
+			continue;
+		}
+		if (SERVER.test(p.command)) {
+			claim(p.pid, "server", {
+				kind: "server",
+				name: "stim-server",
+				workspace: null,
+				id: null,
+				owned: false
+			}, fallbackOf);
+			continue;
+		}
+		const udid = LAUNCHD_SIM.exec(p.command)?.[1]?.toUpperCase();
+		if (udid) {
+			const owner = sims.get(udid) ?? {
+				kind: "simulator",
+				name: simNames[udid] ?? udid,
+				workspace: null,
+				id: udid,
+				owned: false
+			};
+			claim(p.pid, `simulator:${udid}`, owner);
+			continue;
+		}
+		const avd = emulatorAvd(p.command);
+		if (avd) {
+			const owner = emulators.get(avd) ?? {
+				kind: "emulator",
+				name: avd,
+				workspace: null,
+				id: avd,
+				owned: false
+			};
+			claim(p.pid, `emulator:${avd}`, owner);
+		}
+	}
+	const present = new Set(processes.map((p) => p.pid));
+	const byPath = new Map(environments.map((env) => [env.path, env]));
+	for (const root of roots) {
+		const env = byPath.get(root.path);
+		if (!env) continue;
+		const metroPids = [root.supervisorPid, env.metro?.running ? env.metro.pid : null];
+		for (const pid of metroPids) if (pid && present.has(pid)) {
+			const port = env.metro?.port ?? null;
+			claim(pid, `metro:${env.path}`, workspaceOwner("metro", env, port ? `Metro :${port}` : "Metro", port ? String(port) : null));
+		}
+		if (root.build && present.has(root.build.pid)) {
+			const label = root.build.platform === "ios" ? "iOS build" : "Android build";
+			claim(root.build.pid, `build:${env.path}`, workspaceOwner("build", env, label, root.build.platform));
+		}
+		for (const pid of root.browserPids) if (present.has(pid)) claim(pid, `browser:${env.path}`, workspaceOwner("browser", env, "Chrome", null));
+	}
+	const parentOf = new Map(processes.map((p) => [p.pid, p.ppid]));
+	const totals = /* @__PURE__ */ new Map();
+	for (const p of processes) {
+		let pid = p.pid;
+		let key;
+		let fallback;
+		for (let depth = 0; pid !== void 0 && pid > 1 && depth < MAX_DEPTH; depth++) {
+			key = rootOf.get(pid);
+			if (key) break;
+			fallback ??= fallbackOf.get(pid);
+			pid = parentOf.get(pid);
+		}
+		key ??= fallback;
+		if (!key) continue;
+		const total = totals.get(key) ?? {
+			rssKb: 0,
+			cpu: 0,
+			processes: 0
+		};
+		total.rssKb += p.rssKb;
+		total.cpu += p.cpuPercent;
+		total.processes += 1;
+		totals.set(key, total);
+	}
+	const list = [];
+	for (const [key, owner] of owners) {
+		const total = totals.get(key);
+		if (total) list.push({
+			...owner,
+			cpuPercent: Math.round(total.cpu),
+			residentMb: Math.round(total.rssKb / 1024),
+			processes: total.processes
+		});
+	}
+	list.sort((x, y) => rank(x) - rank(y) || (x.workspace ?? "~").localeCompare(y.workspace ?? "~") || x.name.localeCompare(y.name));
+	return { owners: list };
+}
+//#endregion
 //#region src/commands/status.ts
-const WATCH_GIT_MAX_AGE_MS = 5e3;
+const WATCH_GIT_MAX_AGE_MS = 6e4;
 function formatGb(mb) {
 	return `${(mb / 1024).toFixed(1)} GB`;
 }
 function statusCommand(program) {
 	program.command("status").description("Show every environment on this machine: devices, ports, what is actually running, and anything stuck.").option("--json", "print the state as JSON").option("--watch", "keep running and print the state again each time it changes").action(async (opts) => {
 		if (opts.watch) return watchStatus(Boolean(opts.json));
-		for (const line of await statusLines(Boolean(opts.json), 0)) console.log(line);
+		const json = Boolean(opts.json);
+		for (const line of renderStatus(await readStatus(0), json)) console.log(line);
 	});
 }
-async function statusLines(json, gitMaxAgeMs) {
-	const out = [];
+function readStatus(gitMaxAgeMs, simctlListing = null) {
+	return withStateReadCache(() => readStatusFacts(gitMaxAgeMs, simctlListing));
+}
+async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 	const cfg = loadConfig$1();
 	const projects = Object.entries(cfg?.projects || {});
-	const cwdRoot = findProjectRoot(process.cwd());
+	const cwdRoot = findServerWorkspace(process.cwd())?.root ?? null;
 	const worktrees = linkedWorktrees([process.cwd(), ...projects.map(([path]) => path)]);
 	const orphanWorktrees = unprovisionedWorktrees(worktrees, projects.map(([p]) => p));
-	const simsRead = listAllIosSimsAsync();
+	const simsRead = simctlListing === null ? listAllIosSimsAsync() : Promise.resolve().then(() => parseSimctlList(simctlListing));
 	simsRead.catch(() => {});
 	const ports = await portLookup(projects.flatMap(([, proj]) => proj.metroPort ? [proj.metroPort] : []));
 	const processes = Promise.all(projects.map(async ([path, proj]) => {
@@ -630,6 +1019,7 @@ async function statusLines(json, gitMaxAgeMs) {
 	const history = readStats().record?.history;
 	const states = [];
 	const labelOnlyRoots = [];
+	const launchesByState = [];
 	const easLedger = readEasSessionLedger$1();
 	const leaseNow = Date.now();
 	const leaseFiles = listLeaseFiles();
@@ -637,11 +1027,25 @@ async function statusLines(json, gitMaxAgeMs) {
 		root: cwdRoot,
 		now: leaseNow
 	});
+	const roots = [];
 	for (const [i, [path, proj]] of projects.entries()) {
 		const { metro, supervisor } = running[i];
 		const saved = readWorkspaceState$1(path);
 		const builds = workspaceBuilds(path, saved, history);
-		states.push(environmentState({
+		const web = webFacts(readWebRecord(path));
+		const activeBuild = parseActiveBuild(saved?.[ACTIVE_BUILD_KEY]);
+		roots.push({
+			path,
+			supervisorPid: supervisor?.status === "ours" ? supervisor.pid : null,
+			build: activeBuild && builds.build?.state === "running" ? {
+				platform: activeBuild.platform,
+				pid: activeBuild.claim.pid
+			} : null,
+			browserPids: browserPids(web)
+		});
+		const launches = readWorkspaceLaunches(path);
+		launchesByState.push(launches);
+		states.push(withWebFacts(environmentState({
 			...proj,
 			__path: path
 		}, {
@@ -654,38 +1058,86 @@ async function statusLines(json, gitMaxAgeMs) {
 			logs: logs[i],
 			remote: remoteDeviceState(readRemoteSession(path), easLedger, path),
 			idleStop: readIdleStop(saved),
-			launches: readWorkspaceLaunches(path),
+			launches,
 			leasedIds: new Set(deviceLeaseStates(leaseFiles, {
 				root: path,
 				now: leaseNow
 			}).flatMap((lease) => lease.mine && !lease.expired && lease.id ? [lease.id] : [])),
 			now: leaseNow
-		}));
+		}), web));
 		const state = states[states.length - 1];
 		if (state) Object.assign(state, builds);
-		labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android));
-	}
-	const readActivity = createActivityReader();
-	for (const state of states) for (const device of [{
-		slot: "default",
-		ios: state.ios,
-		android: state.android
-	}, ...state.slots ?? []]) {
-		const base = {
-			slot: device.slot,
-			workspace: state.path
-		};
-		if (device.ios?.state === "Booted") device.ios.activity = readActivity({
-			...base,
-			platform: "ios",
-			id: device.ios.udid
-		});
-		if (device.android && !device.android.physical && device.android.serial) device.android.activity = readActivity({
-			...base,
-			platform: "android",
-			id: device.android.serial
-		});
+		labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android && !state?.web));
 	}
+	const tables = createDeviceProcessTables();
+	readDeviceProcesses(states, tables, {
+		projects,
+		launchesByState
+	});
+	const sims = Object.values(simsByUdid);
+	const simNames = Object.fromEntries(sims.map((sim) => [sim.udid.toUpperCase(), sim.name]));
+	const machine = readMachineUsage({
+		states,
+		roots,
+		simNames,
+		tables,
+		busy: sims.some((sim) => sim.state === "Booted")
+	});
+	return {
+		projects,
+		states,
+		labelOnlyRoots,
+		leases,
+		leaseNow,
+		orphanWorktrees,
+		simsAvailable,
+		simctlError,
+		cwdRoot,
+		tables,
+		machine,
+		roots,
+		simNames
+	};
+}
+function browserPids(web) {
+	if (!web) return [];
+	const chrome = web.record.chromeProcess?.pid;
+	if (web.status === "running") return [web.record.pid, ...chrome ? [chrome] : []];
+	return web.status === "orphaned" && chrome ? [chrome] : [];
+}
+/**
+* Attributes the host process table to its owners. Reads the table only when a simulator is booted, a workspace is
+* live or a build runs, so an idle machine runs no `ps`.
+*/
+function readMachineUsage({ states, roots, simNames, tables, busy }) {
+	const processes = busy || states.some((state) => state.live || state.build?.state === "running") ? tables.host() : null;
+	return processes ? attributeMachineUsage({
+		processes,
+		environments: states,
+		roots,
+		simNames
+	}) : null;
+}
+/**
+* Rereads only the error counts, device activity and machine usage. With `machine`, and when the snapshot measured
+* machine usage, it reads the host process table again; it reuses every other subprocess fact of the full read.
+*/
+function refreshLightFacts(snapshot, machine) {
+	if (machine && snapshot.machine) snapshot.tables = {
+		host: createDeviceProcessTables().host,
+		android: snapshot.tables.android
+	};
+	withStateReadCache(() => {
+		for (const state of snapshot.states) state.logs = logFacts(state.path);
+		readDeviceProcesses(snapshot.states, snapshot.tables, null);
+	});
+	if (machine && snapshot.machine) snapshot.machine = readMachineUsage({
+		...snapshot,
+		busy: true
+	});
+}
+function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orphanWorktrees, simsAvailable, simctlError, cwdRoot, machine }, json) {
+	const out = [];
 	const totalMemoryMb = Math.round(totalmem() / 1048576);
 	const cap = capacity(states, totalMemoryMb);
 	const pools = ["ios", "android"].map((platform) => {
@@ -708,7 +1160,8 @@ async function statusLines(json, gitMaxAgeMs) {
 			capacity: cap,
 			deviceLeases: leases,
 			unprovisionedWorktrees: orphanWorktrees,
-			simctlAvailable: simsAvailable
+			simctlAvailable: simsAvailable,
+			machine
 		}));
 		return out;
 	}
@@ -729,7 +1182,7 @@ async function statusLines(json, gitMaxAgeMs) {
 		const marker = path === cwdRoot ? chalk.bold.cyan(`* ${shortcut}`) : shortcut;
 		const idle = state.live ? "" : chalk.dim(" [idle]");
 		out.push(`\n${marker}${idle} ${chalk.dim(`(${path})`)}`);
-		out.push(labelOnlyRoots[i] ? chalk.dim("  worktree root (holds the label; the app registers its own entry)") : chalk.dim(`  app: ${proj.bundleId ?? "?"} (${proj.isExpo ? "expo" : "bare"})`));
+		out.push(labelOnlyRoots[i] ? chalk.dim("  worktree root (holds the label; the app registers its own entry)") : chalk.dim(`  app: ${proj.bundleId ?? "?"} (${proj.isExpo ?? detectIsExpo(path) ? "expo" : "bare"})`));
 		if (state.metro) {
 			const label = state.metro.running ? chalk.green(`running (pid ${state.metro.pid})`) : state.metro.idleStop ? chalk.dim(`stopped (idle) after ${state.metro.idleStop.idleMinutes}m; \`stim start\`, \`ios\` or \`android\` restarts it`) : chalk.dim("not running");
 			out.push(`  metro: port ${state.metro.port} ${label}`);
@@ -759,14 +1212,18 @@ async function statusLines(json, gitMaxAgeMs) {
 			if (deviceState.ios) {
 				const booted = deviceState.ios.state === "Booted" ? chalk.green("booted") : chalk.dim(deviceState.ios.state.toLowerCase());
 				const owned = deviceState.ios.owned ? chalk.dim(" (owned)") : "";
-				out.push(`  ios${slotLabel}: ${chalk.cyan(deviceState.ios.name ?? deviceState.ios.udid)} ${booted}${owned}${activitySuffix(deviceState.ios.activity)}`);
+				out.push(`  ios${slotLabel}: ${chalk.cyan(deviceState.ios.name ?? deviceState.ios.udid)} ${booted}${owned}${activitySuffix(deviceState.ios.activity)}${appSuffix(deviceState.ios.app)}`);
 			}
 			if (deviceState.android) {
 				const kind = deviceState.android.physical ? chalk.dim("(physical)") : chalk.dim("(emulator)");
 				const observed = deviceState.android.state ? ` ${deviceState.android.state}${deviceState.android.serial ? ` (${deviceState.android.serial})` : ""}` : "";
-				out.push(`  android${slotLabel}: ${chalk.cyan(deviceState.android.name)} ${kind}${observed}${deviceState.android.owned ? chalk.dim(" (owned)") : ""}${activitySuffix(deviceState.android.activity)}`);
+				out.push(`  android${slotLabel}: ${chalk.cyan(deviceState.android.name)} ${kind}${observed}${deviceState.android.owned ? chalk.dim(" (owned)") : ""}${activitySuffix(deviceState.android.activity)}${appSuffix(deviceState.android.app)}`);
 			}
 		}
+		if (state.web) {
+			const browser = state.web.running ? chalk.green(`running (pid ${state.web.pid}, DevTools ${state.web.cdpEndpoint})`) : chalk.dim("not running");
+			out.push(`  web: ${chalk.cyan(state.web.url)} ${browser}${state.web.headless ? "" : chalk.dim(" (headed)")}`);
+		}
 		for (const remote of state.remoteDevices ?? []) out.push(`  ${remoteDeviceLine(remote)}`);
 		for (const w of state.warnings) out.push(chalk.yellow(`  ! ${w}`));
 	}
@@ -798,13 +1255,17 @@ async function statusLines(json, gitMaxAgeMs) {
 }
 async function watchStatus(json) {
 	let last = null;
+	let snapshot = null;
 	let sources = null;
 	const scheduler = createRefreshScheduler({
 		debounceMs: 250,
-		run: async () => {
+		lightIntervalMs: WATCH_LIGHT_INTERVAL_MS,
+		run: async (kind) => {
 			let text;
 			try {
-				text = (await statusLines(json, WATCH_GIT_MAX_AGE_MS)).join("\n");
+				if (kind === "light" && snapshot) refreshLightFacts(snapshot, json);
+				else snapshot = await readStatus(WATCH_GIT_MAX_AGE_MS, sources?.simulatorListing());
+				text = renderStatus(snapshot, json).join("\n");
 			} catch (error) {
 				console.error(chalk.red(String(error?.message || error)));
 				return;
@@ -816,9 +1277,11 @@ async function watchStatus(json) {
 			process.stdout.write(`${!json && process.stdout.isTTY ? "\x1B[2J\x1B[H" : ""}${text}\n`);
 		}
 	});
-	const fallback = setInterval(() => scheduler.trigger(), WATCH_FALLBACK_MS);
+	const fallback = setInterval(() => scheduler.trigger("full"), WATCH_FALLBACK_MS);
+	const machine = setInterval(() => json && snapshot?.machine && scheduler.trigger("light"), WATCH_LIGHT_INTERVAL_MS);
 	const finish = () => {
 		clearInterval(fallback);
+		clearInterval(machine);
 		scheduler.stop();
 		sources?.stop();
 		process.exit(0);
@@ -828,9 +1291,9 @@ async function watchStatus(json) {
 	process.stdout.on("error", finish);
 	sources = watchStatusSources({
 		home: getConfigDir(),
-		onChange: () => scheduler.trigger()
+		onChange: (kind) => scheduler.trigger(kind)
 	});
-	scheduler.trigger(0);
+	scheduler.trigger("full", 0);
 	await new Promise(() => {});
 }
 async function readGitInto(worktrees, orphans, maxAgeMs) {
@@ -857,6 +1320,62 @@ function activitySuffix(activity) {
 	const label = activityLabel(activity, Date.now());
 	return label ? ` -- ${activity?.state === "driven" ? chalk.magenta(label) : chalk.dim(label)}` : "";
 }
+function readDeviceProcesses(states, tables, apps) {
+	const readActivity = createActivityReader({ tables });
+	const readAppProcess = createAppProcessReader(tables);
+	for (const [i, state] of states.entries()) {
+		const appIdOn = (platform, slot, deviceId) => {
+			if (!apps) return void 0;
+			const project = apps.projects[i][1];
+			const launch = apps.launchesByState[i][deviceSlotKey(platform, slot)];
+			return launch?.deviceId === deviceId ? launch.appId : platform === "ios" ? project.bundleId : project.androidPackage;
+		};
+		for (const device of [{
+			slot: "default",
+			ios: state.ios,
+			android: state.android
+		}, ...state.slots ?? []]) {
+			const base = {
+				slot: device.slot,
+				workspace: state.path
+			};
+			if (device.ios?.state === "Booted") {
+				const id = device.ios.udid;
+				device.ios.activity = statusActivity(readActivity({
+					...base,
+					platform: "ios",
+					id
+				}));
+				const appId = device.ios.owned ? appIdOn("ios", device.slot, id) : void 0;
+				if (appId) device.ios.app = readAppProcess({
+					platform: "ios",
+					id,
+					appId
+				});
+			}
+			if (device.android && !device.android.physical && device.android.serial) {
+				const id = device.android.serial;
+				device.android.activity = statusActivity(readActivity({
+					...base,
+					platform: "android",
+					id
+				}));
+				const appId = device.android.owned ? appIdOn("android", device.slot, id) : void 0;
+				if (appId) device.android.app = readAppProcess({
+					platform: "android",
+					id,
+					appId
+				});
+			}
+		}
+	}
+}
+function appSuffix(app) {
+	if (!app) return "";
+	if (app.state === "running") return chalk.dim(` -- ${app.id} running`);
+	if (app.state === "stopped") return ` -- ${chalk.yellow(`${app.id} not running`)}`;
+	return chalk.dim(` -- ${app.id} process unknown`);
+}
 function linkedWorktrees(paths) {
 	return [...new Set(paths.flatMap((path) => gitCommonDirOnDisk(path) ?? []))].flatMap((common) => {
 		const repository = basename(common) === ".git" ? dirname(common) : common;
@@ -865,9 +1384,11 @@ function linkedWorktrees(paths) {
 }
 function workspaceBuilds(path, saved, history) {
 	const lastBuilds = readLastBuilds(saved);
+	const builds = readBuildHistory(saved);
 	return {
 		build: workspaceBuild(path, saved, history),
-		...lastBuilds.ios || lastBuilds.android ? { lastBuilds } : {}
+		...lastBuilds.ios || lastBuilds.android ? { lastBuilds } : {},
+		...builds.ios || builds.android ? { builds } : {}
 	};
 }
 function workspaceBuild(path, saved, history) {