stim 1.14.0 → 1.15.0

package/dist/{ios-device-DGglU3E_.mjs → ios-device-DERmMmk-.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { n as TOOL_ERROR_PREFIX } from "./ios-device-BiOsSVzd.mjs";
-import { i as INSTALL_ERROR } from "./app-install-BpgSgkJj.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as TOOL_ERROR_PREFIX } from "./ios-device-Ee7sDXfp.mjs";
+import { i as INSTALL_ERROR } from "./app-install-CAAplXAt.mjs";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -38,12 +38,17 @@ function parseDevicectlDevices(payload) {
 			transportType: text(connection.transportType),
 			platform: text(hardware.platform),
 			reality: text(hardware.reality),
-			tunnelState: text(connection.tunnelState)
+			tunnelState: text(connection.tunnelState),
+			model: text(hardware.marketingName)
 		});
 	}
 	return out;
 }
 function listIosDevices({ exec = null } = {}) {
+	return readIosDevices({ exec }) ?? [];
+}
+/** devicectl's device list, or null when devicectl failed or did not answer within `timeoutMs`. */
+function readIosDevices({ exec = null, timeoutMs = DEVICECTL_TIMEOUT_MS } = {}) {
 	const executor = exec || getExecutor();
 	const dir = mkdtempSync(join(tmpdir(), "stim-devicectl-"));
 	const out = join(dir, "devices.json");
@@ -54,10 +59,10 @@ function listIosDevices({ exec = null } = {}) {
 			"devices",
 			"-j",
 			out
-		], { timeoutMs: DEVICECTL_TIMEOUT_MS });
+		], { timeoutMs });
 		return parseDevicectlDevices(readFileSync(out, "utf-8"));
 	} catch {
-		return [];
+		return null;
 	} finally {
 		rmSync(dir, {
 			recursive: true,
@@ -507,4 +512,4 @@ function localNetworkPending(records, { since = 0, pid = null, lanOrigin }) {
 	return false;
 }
 //#endregion
-export { iosPoolCandidates as a, listIosDevices as c, verifyIosDeviceReleaseLaunch as d, iosDeviceProcess as i, localNetworkPending as l, installIosDeviceApp as n, iosPoolNoCandidatesRefusal as o, iosDeviceBounds as r, isWirelessIosDevice as s, awaitIosDeviceLaunch as t, resolveIosPhysicalDevice as u };
+export { iosPoolCandidates as a, isWirelessIosDevice as c, readIosDevices as d, resolveIosPhysicalDevice as f, iosDeviceProcess as i, listIosDevices as l, installIosDeviceApp as n, iosPoolNoCandidatesRefusal as o, verifyIosDeviceReleaseLaunch as p, iosDeviceBounds as r, isReachable as s, awaitIosDeviceLaunch as t, localNetworkPending as u };

package/dist/{ios-device-BiOsSVzd.mjs → ios-device-Ee7sDXfp.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 //#region src/collector/ios-device.ts
 const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
 const DEV_MENU_LAUNCH_ARGS = [

package/dist/{launch-verify-Deg4tB3Z.mjs → launch-verify-CLlofxRt.mjs}

@@ -1,8 +1,8 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { o as readNdjsonGenerations } from "./ndjson-CDY9IkVC.mjs";
-import { s as isAppLaunchError } from "./command-output-DVcpw6eE.mjs";
-import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-BiOsSVzd.mjs";
-import { d as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, o as androidAppProcess } from "./app-install-BpgSgkJj.mjs";
+import { s as isAppLaunchError } from "./command-output-CliHHn7a.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Ee7sDXfp.mjs";
+import { f as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, s as androidAppProcess } from "./app-install-CAAplXAt.mjs";
 import { join } from "node:path";
 //#region src/engine/app-readiness.ts
 const APP_READINESS_TIMEOUT_MS = 3e4;

package/dist/{logs-Civ4gbBH.mjs → logs-h9h6MUvE.mjs}

@@ -1,13 +1,16 @@
-import { H as parseDeviceSlotOption, O as process_identity_exports, U as projectDeviceSlots, _ as loadConfig$1, g as isPathPrefix } from "./config-lvc7d3C2.mjs";
+import { H as projectDeviceSlots, V as parseDeviceSlotOption, _ as loadConfig$1, g as isPathPrefix } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { n as SOURCES, t as LEVELS } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir, h as readWorkspaceState$1 } from "./metro-CcEo8Fl8.mjs";
-import { i as findCommandWorkspace } from "./project-CWlvEaeN.mjs";
-import { f as refuseNoProject, v as launchErrorPreview } from "./command-output-DVcpw6eE.mjs";
-import { a as readAgentDeviceRecords, t as agentDeviceLiveness } from "./activity-CYVDcrt3.mjs";
-import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-C5HzcwCW.mjs";
+import { C as workspaceLogsDir, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
+import { i as findCommandWorkspace } from "./project-CV3tDFHl.mjs";
+import { o as readAgentDeviceRecords, t as agentDeviceLiveness } from "./activity-B2-kb7k0.mjs";
+import { f as refuseNoProject, l as phaseLine, v as launchErrorPreview } from "./command-output-CliHHn7a.mjs";
+import { a as pullHostedMacosLogs, t as connectHost } from "./hosted-macos-DwowNU7W.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-Cb0P1WLS.mjs";
+import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
 import { closeSync, fstatSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { attachExpoErrorContext, buildCriteria, compileGrep, fileSizes, followLogs, logFiles, parseSince, queryLogs, readLogRecords, recordMatches, sortByTs } from "@stim-cli/core/state";
 import { join, relative, resolve, sep } from "node:path";
+import { attachExpoErrorContext, buildCriteria, compileGrep, fileSizes, followLogs, logFiles, parseSince, queryLogs, readLogRecords, readMacosRecord, recordMatches, sortByTs } from "@stim-cli/core/state";
 import { homedir } from "node:os";
 import chalk from "chalk";
 //#region src/devices/agent-actions.ts
@@ -17,6 +20,8 @@ function object(value) {
 }
 function parseAgentEvents(lines) {
 	const events = [];
+	const started = [];
+	const finished = [];
 	let session = null;
 	let unknownVersion = null;
 	for (const line of lines) {
@@ -37,9 +42,14 @@ function parseAgentEvents(lines) {
 		}
 		if (typeof entry.session === "string") session ??= entry.session;
 		const { kind, command, summary } = entry;
+		const requestId = typeof entry.requestId === "string" ? entry.requestId : null;
+		if (kind === "request.started" && requestId && Number.isFinite(ts)) started.push([requestId, ts]);
 		if (kind !== "action.recorded" && kind !== "request.finished") continue;
 		const failed = kind === "request.finished" && entry.status === "error";
-		if (kind === "request.finished" && !failed) continue;
+		if (kind === "request.finished" && !failed) {
+			if (requestId) finished.push(requestId);
+			continue;
+		}
 		if (!Number.isFinite(ts) || typeof entry.session !== "string" || typeof command !== "string") continue;
 		if (typeof summary !== "string") continue;
 		events.push({
@@ -49,11 +59,14 @@ function parseAgentEvents(lines) {
 			command,
 			summary,
 			failed,
-			details: object(entry.details)
+			details: object(entry.details),
+			requestId
 		});
 	}
 	return {
 		events,
+		started,
+		finished,
 		session,
 		unknownVersion
 	};
@@ -103,9 +116,10 @@ function spanDevice(spans, ts) {
 	for (const span of spans) if (span.from <= ts) device = span.deviceId;
 	return device;
 }
-function agentRecord(event, deviceId, target) {
+function agentRecord(event, deviceId, target, startedAt) {
 	return {
 		ts: event.ts,
+		...startedAt !== void 0 && startedAt <= event.ts ? { startedAt } : {},
 		src: "agent",
 		level: event.failed ? "error" : "info",
 		msg: event.summary,
@@ -221,7 +235,8 @@ function createAgentActionReader({ targets, sinceTs = -Infinity, home = homedir(
 					closes: [],
 					runner: null,
 					session: null,
-					unknownReported: false
+					unknownReported: false,
+					started: /* @__PURE__ */ new Map()
 				};
 				cursors.set(name, cursor);
 				try {
@@ -234,8 +249,13 @@ function createAgentActionReader({ targets, sinceTs = -Infinity, home = homedir(
 			cursor.offset = chunk.next;
 			lines.push(...chunk.text.split("\n"));
 			const parsed = parseAgentEvents(lines);
+			for (const [requestId, at] of parsed.started) cursor.started.set(requestId, at);
 			cursor.session ??= parsed.session;
 			const session = cursor.session;
+			const matched = new Map(parsed.events.flatMap((event) => event.requestId && cursor.started.has(event.requestId) ? [[event.requestId, cursor.started.get(event.requestId)]] : []));
+			const failed = parsed.events.flatMap((event) => event.failed && event.requestId ? [event.requestId] : []);
+			for (const requestId of [...parsed.finished, ...failed]) cursor.started.delete(requestId);
+			for (const requestId of [...cursor.started.keys()].slice(0, -64)) cursor.started.delete(requestId);
 			if (!parsed.events.length && !parsed.unknownVersion) continue;
 			const runnerPath = join(dir, "runner.log");
 			let runnerSize = -1;
@@ -267,13 +287,69 @@ function createAgentActionReader({ targets, sinceTs = -Infinity, home = homedir(
 				if (event.ts < sinceTs) continue;
 				const deviceId = deviceAt(event.ts);
 				const target = deviceId ? byId.get(deviceId) : void 0;
-				if (target && deviceId) out.push(agentRecord(event, deviceId, target));
+				const startedAt = event.requestId ? matched.get(event.requestId) : void 0;
+				if (target && deviceId) out.push(agentRecord(event, deviceId, target, startedAt));
 			}
 		}
 		return out.toSorted((a, b) => a.ts - b.ts);
 	};
 }
 //#endregion
+//#region src/device-host/hosted-logs-sync.ts
+function warning(machine, error) {
+	const message = error.message.replace(/\.$/, "");
+	const hint = message.includes("refused device-host.logs.query") ? ` If ${machine} runs an older stim-server, update it.` : "";
+	return phaseLine("device", `Could not read the app's logs from ${machine}: ${message}. Showing the logs already copied here.${hint}`);
+}
+async function syncHostedMacosLogs(root, placement) {
+	let host;
+	try {
+		host = await connectHost(placement.machine);
+		await pullHostedMacosLogs(root, placement, host);
+		return true;
+	} catch (error) {
+		process.stderr.write(`${warning(placement.machine, error)}\n`);
+		return false;
+	} finally {
+		host?.connection.close();
+	}
+}
+function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3 } = {}) {
+	let host;
+	let retryAt = 0;
+	let stopped = false;
+	let running = false;
+	const tick = async () => {
+		if (running || stopped || Date.now() < retryAt) return;
+		running = true;
+		try {
+			const placement = readMacosRecord(root)?.host;
+			if (!placement) {
+				host?.connection.close();
+				host = void 0;
+				return;
+			}
+			host ??= await connectHost(placement.machine);
+			await pullHostedMacosLogs(root, placement, host);
+			failing = false;
+		} catch (error) {
+			host?.connection.close();
+			host = void 0;
+			if (!failing) process.stderr.write(`${warning(readMacosRecord(root)?.host?.machine ?? "the host", error)}\n`);
+			failing = true;
+			retryAt = Date.now() + retryMs;
+		} finally {
+			running = false;
+		}
+	};
+	const timer = setInterval(() => void tick(), intervalMs);
+	return () => {
+		stopped = true;
+		clearInterval(timer);
+		host?.connection.close();
+	};
+}
+//#endregion
 //#region src/commands/logs.ts
 const LEVEL_WIDTH = 5;
 const SRC_WIDTH = 6;
@@ -359,7 +435,7 @@ const LEVEL_COLOURS = {
 	fatal: chalk.bgRed
 };
 function logsCommand(program) {
-	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build, agent-device actions). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only records attributed to this device slot", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, agent, or all").option("--level <l>", `Minimum level: ${LEVELS.join(", ")}`).option("--since <d>", "Only records newer than this, e.g. 30s, 5m, 2h").option("--grep <re>", "Only records whose message matches this regular expression").option("--tail <n>", "Only the last n matching records").option("--errors", "Errors and fatals since the last marker, from metro, client and build, plus confirmed native app-crash reports and stim web browser errors. Add --source device or --source all for general device errors.").option("--follow", "Keep streaming new records until interrupted").option("--json", "Emit the raw records, one per line (valid NDJSON; zero matches is zero bytes, exit 0)").action(async (opts) => {
+	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build, agent actions). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only this device slot's records, plus the shared Metro and app client records once it has launched", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, agent, or all").option("--level <l>", `Minimum level: ${LEVELS.join(", ")}`).option("--since <d>", "Only records newer than this, e.g. 30s, 5m, 2h").option("--grep <re>", "Only records whose message matches this regular expression").option("--tail <n>", "Only the last n matching records").option("--errors", "Errors and fatals since the last marker, from metro, client and build, plus confirmed native app-crash reports and stim web browser errors. Add --source device or --source all for general device errors.").option("--follow", "Keep streaming new records until interrupted").option("--json", "Emit the raw records, one per line (valid NDJSON; zero matches is zero bytes, exit 0)").action(async (opts) => {
 		const root = findCommandWorkspace(process.cwd());
 		if (!root) {
 			refuseNoProject({ json: false });
@@ -393,6 +469,8 @@ function logsCommand(program) {
 			if (compiled.error) fail(compiled.error);
 		}
 		requireLogsWorkspace(root, dir);
+		const hosted = readMacosRecord(root)?.host;
+		const hostedReachable = hosted ? await syncHostedMacosLogs(root, hosted) : true;
 		const query = {
 			slot: opts.slot,
 			dir,
@@ -469,11 +547,15 @@ function logsCommand(program) {
 		const agentTimer = readAgent ? setInterval(() => {
 			for (const record of readAgent()) if (recordMatches(record, criteria)) emit(record);
 		}, 500) : null;
+		const stopHosted = hosted ? followHostedMacosLogs(root, { failing: !hostedReachable }) : null;
 		const finish = () => {
 			stop();
+			stopHosted?.();
+			stopReader();
 			if (agentTimer) clearInterval(agentTimer);
 			process.exit(0);
 		};
+		const stopReader = watchStdoutReader(finish);
 		process.on("SIGINT", finish);
 		process.on("SIGTERM", finish);
 	});

package/dist/machine-usage-D_YYMzfR.mjs

@@ -0,0 +1,283 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { basename, dirname, join } from "node:path";
+import { compiledHelper, configDir } from "@stim-cli/core";
+import { MACHINE_OWNER_KINDS } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
+//#region src/footprint.ts
+const SOURCE = "stim-footprint.swift";
+const COMPILE_TIMEOUT_MS = 12e4;
+const READ_TIMEOUT_MS = 5e3;
+function helperSource() {
+	const here = fileURLToPath(import.meta.url);
+	if (basename(dirname(here)) === "src") return fileURLToPath(new URL(`../helper/${SOURCE}`, import.meta.url));
+	return join(dirname(here), SOURCE);
+}
+async function buildHelper() {
+	const exec = getExecutor();
+	if (!exec.runFileQuiet("xcode-select", ["-p"], { timeoutMs: READ_TIMEOUT_MS })) return null;
+	const source = helperSource();
+	try {
+		return await compiledHelper({
+			dir: join(configDir(), "helpers"),
+			name: "stim-footprint",
+			inputs: [source],
+			version: "",
+			compile: async (output) => {
+				await exec.runFileAsync("xcrun", [
+					"swiftc",
+					"-O",
+					"-swift-version",
+					"5",
+					"-o",
+					output,
+					source
+				], { timeoutMs: COMPILE_TIMEOUT_MS });
+			}
+		});
+	} catch {
+		return null;
+	}
+}
+const RETRY_BACKOFF_INITIAL_MS = 1e4;
+const RETRY_BACKOFF_MAX_MS = 6e5;
+let built = null;
+let failure = null;
+/** The `stim-footprint` helper, compiled on first use. A success is kept for the process's life; a failure retries after a doubling backoff instead of being pinned forever. */
+function footprintHelper() {
+	const home = configDir();
+	if (built?.home === home) return built.promise;
+	if (failure?.home === home && Date.now() < failure.nextRetryAt) return Promise.resolve(null);
+	const promise = buildHelper().then((helper) => {
+		if (helper === null) {
+			const backoffMs = failure?.home === home ? Math.min(failure.backoffMs * 2, RETRY_BACKOFF_MAX_MS) : RETRY_BACKOFF_INITIAL_MS;
+			failure = {
+				home,
+				nextRetryAt: Date.now() + backoffMs,
+				backoffMs
+			};
+			if (built?.promise === promise) built = null;
+			return null;
+		}
+		return helper;
+	});
+	built = {
+		home,
+		promise
+	};
+	return promise;
+}
+/** Parses the helper's `<pid> <bytes>` lines into footprint bytes by pid. */
+function parseFootprints(output) {
+	const footprints = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const match = /^(\d+) (\d+)$/.exec(line.trim());
+		if (match) footprints.set(Number(match[1]), Number(match[2]));
+	}
+	return footprints;
+}
+/** Every readable process's physical footprint in bytes, or null when the helper is unavailable or fails. */
+async function readFootprints() {
+	const helper = await footprintHelper();
+	const output = helper ? getExecutor().runFileQuiet(helper, [], { timeoutMs: READ_TIMEOUT_MS }) : null;
+	return output === null ? null : parseFootprints(output);
+}
+//#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 STIM_SERVER_COMMAND = /(^|[\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. An emulator counts in the workspace that records its AVD whenever its process runs, including while adb
+* does not list it. A process with no root ancestor is left out. `footprints` holds physical footprint bytes by pid,
+* or is null when they could not be read, and the owners' `memoryMb` then sums resident sizes. A process missing from
+* `footprints`, another user's or one that exited between the two reads, counts its resident size.
+*/
+function attributeMachineUsage({ processes, footprints, 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) 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 (STIM_SERVER_COMMAND.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.macosPids ?? []) if (present.has(pid)) claim(pid, `macos:${env.path}`, workspaceOwner("macos", env, env.macos?.product ?? "macOS app", null));
+		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,
+			memoryKb: 0,
+			cpu: 0,
+			processes: 0
+		};
+		total.rssKb += p.rssKb;
+		const footprint = footprints?.get(p.pid);
+		total.memoryKb += footprint === void 0 ? p.rssKb : footprint / 1024;
+		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),
+			memoryMb: Math.round(total.memoryKb / 1024),
+			processes: total.processes
+		});
+	}
+	list.sort((x, y) => rank(x) - rank(y) || (x.workspace ?? "~").localeCompare(y.workspace ?? "~") || x.name.localeCompare(y.name));
+	return {
+		memorySource: footprints ? "footprint" : "rss",
+		owners: list
+	};
+}
+//#endregion
+export { attributeMachineUsage as n, readFootprints as r, STIM_SERVER_COMMAND as t };