stim 1.18.0 → 1.20.0

package/dist/{start-D-IeOyoK.mjs → start-CdvcTaXr.mjs}

@@ -1,29 +1,36 @@
 import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { _ as stepTimer, l as phaseLine } from "./command-output-CBtzyIgF.mjs";
-import { E as upsertProject, p as getProject } from "./config-CgYMahz7.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-CsKYexJM.mjs";
-import { f as readAppConfigText, i as detectIsExpo, n as appProjectProblem, p as readAppJson, s as findProjectRoot$1, t as NO_PROJECT_REFUSAL } from "./project-C3ChRLZy.mjs";
-import { l as resolveProjectMetro, o as pidExists, p as reserveMetroPort, u as signalProcessTree } from "./metro-Dh8T4Ytd.mjs";
-import { c as writeWorkspaceState, g as workspaceAgentDeviceDir, i as recordWorkspaceUse, m as supervisorLogFile, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, u as ensureWorkspaceStorage, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
-import { Ht as readMetroTunnel, Rt as clearManagedMetroTunnel, d as stopOwnedMetroForReset, t as budgetGate } from "./budget-DIhL2BKx.mjs";
-import { _ as terminateChild, b as withManagedTunnelLock, g as stopTunnel, h as startTunnelSequence, m as resolveSupervisorTarget, v as withManagedRemoteWorktreeLock } from "./workspaces-xXItD8Dj.mjs";
-import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Behws_fi.mjs";
-import { A as publicUrlSetting, F as resolveSettings, G as PUBLIC_METRO_ENV, H as tunnelModeSetting, K as detectProviders, M as remoteAndroidSetting, N as remoteIosSetting, P as resolveCacheProviderConfig, S as metroTunnelSettingError, U as unknownSettingKeys, b as metroIdleStopMinutesSetting, d as deviceIdleShutdownMinutesSetting, i as SETTING_SHAPE_REMEDY, q as planMetroReach, u as cacheProviderSettingError, w as ngrokUrlSetting, x as metroPortSetting, z as settingShapeErrors } from "./settings-CQyMElEP.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-BFIz1Shz.mjs";
-import { i as levelRank } from "./ndjson-LGZAMsqa.mjs";
-import { d as readProjectConfig } from "./remote-cache-BGg7aGIZ.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-BLfcgc4O.mjs";
+import { E as upsertProject, p as getProject } from "./config-D0LhTY3S.mjs";
+import { A as metroIdleStopMinutesSetting, B as remoteAndroidSetting, G as resolveIosProjectDir, H as remoteIosSetting, K as resolveProjectSettings, L as publicUrlSetting, M as metroTunnelSettingError, O as metroCommandSetting, P as ngrokUrlSetting, Q as settingShapeErrors, U as resolveAndroidLayout, W as resolveCacheProviderConfig, a as SETTING_SHAPE_REMEDY, at as detectProviders, h as deviceIdleShutdownMinutesSetting, it as PUBLIC_METRO_ENV, j as metroPortSetting, k as metroCommandSettingError, m as defaultAndroidLayout, nt as unknownSettingKeys, ot as planMetroReach, p as cacheProviderSettingError, tt as tunnelModeSetting } from "./settings-Bbztm4oV.mjs";
+import { _ as supervisorLogFile, c as writeWorkspaceState, i as recordWorkspaceUse, n as clearWorkspaceStateKeys, p as ensureWorkspaceStorage, r as readWorkspaceState$1, w as workspaceLogsDir$1, y as workspaceAgentDeviceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { C as MODE_BARE, D as clearManagedMetroTunnel, T as MODE_EXPO, _ as detectIsExpo, b as readAppConfigText, j as readMetroTunnel, r as findProjectRoot, s as projectProblem, t as NO_PROJECT_REFUSAL, w as MODE_COMMAND, x as readAppJson } from "./project-B8_duAzW.mjs";
+import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-8GQX2OV8.mjs";
+import { d as signalProcessTree, g as PortInspectionError, h as PORT_INSPECTION_REMEDY, m as reserveMetroPort, s as pidExists, u as resolveProjectMetro } from "./metro-D_j9sN-B.mjs";
+import { D as stopTunnel, E as startTunnelSequence, O as terminateChild, P as resolveSupervisorTarget, j as withManagedTunnelLock, k as withManagedRemoteWorktreeLock } from "./workspaces-D2xSHBDY.mjs";
+import { ct as stopOwnedMetroForReset, t as budgetGate } from "./budget-BONq9vXY.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-C2lvoPsb.mjs";
+import { i as levelRank } from "./ndjson-GOnbyvso.mjs";
+import { d as readProjectConfig } from "./remote-cache-Bsts6f6Y.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-BXq4fIl-.mjs";
 import { appendFileSync, mkdirSync, openSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { join as join$1 } from "path";
 import { IDLE_STOP_KEY, queryLogs } from "@stim-cli/core/state";
-import chalk from "chalk";
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1 } from "fs";
 import { CACHE_PROVIDER_ENV, cacheProviderEnv } from "@stim-cli/cache";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1 } from "fs";
+import chalk from "chalk";
 import { EventEmitter } from "node:events";
 //#region src/workspace/app-id.ts
+const ANDROID_PACKAGE_NAME = /^[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+$/;
+function androidPackageFilter(problems) {
+	return (id, source) => {
+		if (id === null || ANDROID_PACKAGE_NAME.test(id)) return id;
+		problems.push(`Invalid Android package ${JSON.stringify(id)} in ${source}. Expected dot-separated letters, digits and underscores, such as com.example.app.`);
+		return null;
+	};
+}
 function configString(config, platform, key) {
 	if (!config || typeof config !== "object") return null;
 	const expoField = config.expo;
@@ -48,21 +55,23 @@ function idsFromConfig(projectRoot) {
 		androidPackage: configString(appJson, "android", "package") ?? literalString(text, "package")
 	};
 }
-function detectAppIds(projectRoot) {
+function detectAppIds(projectRoot, iosDir = join$1(projectRoot, "ios"), androidModuleDir = defaultAndroidLayout(projectRoot).moduleDir) {
 	const ids = idsFromConfig(projectRoot);
+	const problems = [];
+	const accept = androidPackageFilter(problems);
 	return {
-		bundleId: ids.bundleId ?? detectBundleIdFromPbxproj(projectRoot),
-		androidPackage: ids.androidPackage ?? detectAndroidPackageFromGradle(projectRoot)
+		bundleId: ids.bundleId ?? detectBundleIdFromPbxproj(iosDir),
+		androidPackage: accept(ids.androidPackage, "the Expo config android.package") ?? detectAndroidPackageFromGradle(androidModuleDir, accept),
+		androidPackageProblem: problems.length > 0 ? problems.join(" ") : null
 	};
 }
-function detectBundleId(projectRoot) {
-	return detectAppIds(projectRoot).bundleId;
+function detectBundleId(projectRoot, iosDir = join$1(projectRoot, "ios")) {
+	return detectAppIds(projectRoot, iosDir).bundleId;
 }
-function detectAndroidPackage(projectRoot) {
-	return detectAppIds(projectRoot).androidPackage;
+function detectAndroidPackage(projectRoot, androidModuleDir = defaultAndroidLayout(projectRoot).moduleDir) {
+	return detectAppIds(projectRoot, void 0, androidModuleDir).androidPackage;
 }
-function detectBundleIdFromPbxproj(projectRoot) {
-	const iosDir = join$1(projectRoot, "ios");
+function detectBundleIdFromPbxproj(iosDir) {
 	if (!existsSync$1(iosDir)) return null;
 	let entries;
 	try {
@@ -94,20 +103,20 @@ function detectBundleIdFromPbxproj(projectRoot) {
 	}
 	return null;
 }
-function detectAndroidPackageFromGradle(projectRoot) {
-	const gradle = join$1(projectRoot, "android", "app", "build.gradle");
-	if (!existsSync$1(gradle)) return null;
+function detectAndroidPackageFromGradle(moduleDir, accept) {
+	const gradle = [join$1(moduleDir, "build.gradle"), join$1(moduleDir, "build.gradle.kts")].find((file) => existsSync$1(file));
+	if (!gradle) return null;
 	let text;
 	try {
 		text = readFileSync$1(gradle, "utf-8");
 	} catch {
 		return null;
 	}
-	const nsId = text.match(/namespace\s+["']([^"']+)["']/)?.[1];
-	if (nsId) return nsId;
-	const appId = text.match(/applicationId\s+["']([^"']+)["']/)?.[1];
-	if (appId) return appId;
-	return null;
+	const nsId = text.match(/namespace\s*=?\s*["']([^"']+)["']/)?.[1];
+	const namespace = nsId ? accept(nsId, gradle) : null;
+	if (namespace) return namespace;
+	const appId = text.match(/applicationId\s*=?\s*["']([^"']+)["']/)?.[1];
+	return appId ? accept(appId, gradle) : null;
 }
 //#endregion
 //#region src/commands/start.ts
@@ -175,9 +184,14 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function startCommand(program) {
 	registerStart(program);
 }
-function recordedSupervisorProcess(pid) {
+function supervisorSignalable(child, inspectIdentity = process_identity_exports.inspectProcessIdentity) {
+	return !child.recordedIdentity || inspectIdentity(child.recordedIdentity) === "same";
+}
+function recordedSupervisorProcess(recorded) {
+	const pid = typeof recorded?.pid === "number" ? recorded.pid : void 0;
 	return Object.assign(new EventEmitter(), {
 		pid,
+		...recorded ? { recordedIdentity: recorded } : {},
 		stdout: null,
 		stderr: null,
 		kill: (signal = "SIGTERM") => pid !== void 0 && signalProcessTree(pid, typeof signal === "number" ? "SIGTERM" : signal),
@@ -251,13 +265,13 @@ function registerStart(program, overrides = {}) {
 			remedy: "Pass a whole number of seconds, e.g. --wait 90."
 		});
 		const waitSeconds = wait.seconds;
-		const root = findProjectRoot$1(process.cwd());
+		const root = findProjectRoot(process.cwd());
 		if (!root) return fail(NO_PROJECT_REFUSAL);
-		const projectProblem = appProjectProblem(root);
-		if (projectProblem) return fail({
+		const problem = projectProblem(root, "dev-server");
+		if (problem) return fail({
 			code: "STIM_NO_PROJECT",
-			message: projectProblem.message,
-			remedy: projectProblem.remedy
+			message: problem.message,
+			remedy: problem.remedy
 		});
 		try {
 			ensureWorkspaceStorage(root);
@@ -269,12 +283,7 @@ function registerStart(program, overrides = {}) {
 			});
 		}
 		recordWorkspaceUse(root);
-		const settingsContext = {
-			projectPath: root,
-			gitCommonDir: gitCommonDir(root),
-			repoRoot: repoRoot(root) ?? root
-		};
-		const settings = resolveSettings(settingsContext);
+		const { context: settingsContext, settings } = resolveProjectSettings(root);
 		const [shapeError, ...moreShapeErrors] = settingShapeErrors(settings);
 		if (shapeError) return fail({
 			code: "STIM_BAD_ARG",
@@ -288,6 +297,7 @@ function registerStart(program, overrides = {}) {
 		const result = await startDevServer({
 			root,
 			settings,
+			settingsContext,
 			waitSeconds,
 			remote: Boolean(opts.remote),
 			resetCache: Boolean(opts.resetCache),
@@ -316,7 +326,7 @@ var StartRefusal = class extends Error {
 		this.refusal = refusal;
 	}
 };
-async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECONDS, remote: remoteFlag = false, resetCache = false, out, note }, overrides = {}) {
+async function startDevServer({ root, settings, settingsContext, waitSeconds = DEFAULT_WAIT_SECONDS, remote: remoteFlag = false, resetCache = false, out, note }, overrides = {}) {
 	const d = {
 		...DEFAULT_START_DEPS,
 		...overrides
@@ -327,12 +337,11 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		throw new StartRefusal(refusal);
 	};
 	const isExpo = detectIsExpo(root);
-	const worktreeRoot = repoRoot(root) ?? root;
-	const cacheProvider = resolveCacheProviderConfig({
-		projectPath: root,
-		gitCommonDir: gitCommonDir(root),
-		repoRoot: worktreeRoot
-	});
+	const metroCommand = metroCommandSetting(settings);
+	const serverMode = metroCommand ? MODE_COMMAND : isExpo ? MODE_EXPO : MODE_BARE;
+	const expoServer = serverMode === MODE_EXPO;
+	const worktreeRoot = settingsContext.repoRoot ?? root;
+	const cacheProvider = resolveCacheProviderConfig(settingsContext);
 	const run = async () => {
 		const settingError = metroTunnelSettingError(settings);
 		if (settingError) return fail({
@@ -340,11 +349,27 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			message: settingError,
 			remedy: "Set metro.tunnel to \"ngrok\" and metro.ngrokUrl to an HTTPS URL, or remove metro.ngrokUrl."
 		});
+		if (metroCommand && d.platform === "win32") return fail({
+			code: "STIM_BAD_ARG",
+			message: "metro.command is not supported on Windows: Stim cannot read a process working directory there, so it cannot prove the Metro a wrapper starts belongs to this app.",
+			remedy: "Remove metro.command on Windows, or run this app from macOS or Linux."
+		});
+		if (metroCommand && resetCache) return fail({
+			code: "STIM_BAD_ARG",
+			message: "--reset-cache cannot reach a dev server started by metro.command; Stim does not know its reset flag.",
+			remedy: "Add the command's own cache-reset flag to metro.command (for React Native, --reset-cache), then run stim stop and stim start."
+		});
+		const commandError = metroCommandSettingError(settings);
+		if (commandError) return fail({
+			code: "STIM_BAD_ARG",
+			message: commandError,
+			remedy: "Set metro.command to the argv that starts the dev server, e.g. [\"npx\", \"react-native\", \"start\", \"--port\", \"{port}\"], or remove it."
+		});
 		const remote = remoteFlag || remoteIosSetting(settings)?.kind === "backend" || remoteAndroidSetting(settings)?.kind === "backend";
 		const tunnelMode = tunnelModeSetting(settings) ?? "auto";
 		const publicUrl = publicUrlSetting(settings);
 		const tunnel = wantsExpoOwnTunnel({
-			isExpo,
+			isExpo: expoServer,
 			remote,
 			mode: tunnelMode,
 			publicUrl
@@ -352,7 +377,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		if (tunnel) note(chalk.dim("note   requesting an Expo tunnel for this workspace's dev server"));
 		const managedRemote = remote && !tunnel && !publicUrl && tunnelMode !== "off";
 		const runStart = async () => {
-			const appIds = detectAppIds(root);
+			const appIds = detectAppIds(root, resolveIosProjectDir(settings, root).dir, resolveAndroidLayout(settings, root, settingsContext.repoRoot ?? root).moduleDir);
 			upsertProject(root, {
 				bundleId: appIds.bundleId ?? void 0,
 				androidPackage: appIds.androidPackage ?? void 0,
@@ -368,9 +393,9 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			};
 			if (resetCache) {
 				await gateBudget();
-				const pin = metroPortSetting(root);
+				const pin = metroPortSetting(settings);
 				if (pin.port !== null || pin.error) {
-					const pinCheck = await resolveWorkspaceMetroPort(root, note, "start", false);
+					const pinCheck = await resolveWorkspaceMetroPort(root, settings, note, "start", false);
 					if (typeof pinCheck !== "number") return fail(pinCheck);
 				}
 				try {
@@ -387,7 +412,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			}
 			const logsDir = workspaceLogsDir$1(root);
 			const logFile = supervisorLogFile(root);
-			const port = await resolvePort(root, note, fail);
+			const port = await resolvePort(root, settings, note, fail);
 			let publicOrigin = remote ? publicUrl : null;
 			let resolution = await resolveProjectMetro(port, root);
 			let supervisor = liveSupervisor({
@@ -438,11 +463,14 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				});
 				return child;
 			};
-			const recordedSupervisorPid = async (since) => {
+			const recordedSupervisor = async (since) => {
 				const deadline = Date.now() + RECORDED_SUPERVISOR_WAIT_MS;
 				while (Date.now() < deadline) {
 					const record = readWorkspaceState$1(root)?.supervisor;
-					if (record?.pid && record.port === port && Date.parse(String(record.startedAt)) >= since && pidExists(record.pid)) return record.pid;
+					if (record?.pid && record.port === port && Date.parse(String(record.startedAt)) >= since && pidExists(record.pid)) return {
+						pid: record.pid,
+						processToken: record.processToken
+					};
 					await sleep(25);
 				}
 				return null;
@@ -483,8 +511,8 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					}));
 				});
 				const launcherFailed = exit.code !== 0 || exit.error;
-				const pid = launcherFailed ? null : await recordedSupervisorPid(since);
-				if (pid === null) {
+				const recorded = launcherFailed ? null : await recordedSupervisor(since);
+				if (recorded === null) {
 					const reason = launcherFailed ? `the supervisor launcher exited (${exit.error ? exit.error.message : `code ${exit.code}`})` : `the supervisor did not record itself within ${RECORDED_SUPERVISOR_WAIT_MS / 1e3}s`;
 					appendFileSync(logFile, `Stim start: ${reason}.\n${stderr.join("")}`);
 					childExit = {
@@ -493,7 +521,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 						...exit.error ? { error: exit.error } : {}
 					};
 				}
-				return recordedSupervisorProcess(pid ?? void 0);
+				return recordedSupervisorProcess(recorded);
 			};
 			const spawnSupervisor = async (origin) => {
 				mkdirSync(logsDir, { recursive: true });
@@ -520,7 +548,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				};
 				childEnv[CACHE_PROVIDER_ENV] = cacheProviderEnv(cacheProvider);
 				const child = d.platform === "win32" ? await spawnThroughWindowsShell(supervisorArgs, childEnv) : spawnDirect(supervisorArgs, childEnv);
-				out(chalk.dim(phaseLine("metro", `starting on port ${port} (${isExpo ? "expo-child" : "bare-inproc"}, supervisor pid ${child.pid})`)));
+				out(chalk.dim(phaseLine("metro", `starting on port ${port} (${serverMode}, supervisor pid ${child.pid})`)));
 				spawnedChild = child;
 				return child;
 			};
@@ -544,7 +572,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					mode: tunnelMode,
 					metroPort: port,
 					publicUrl,
-					isExpo,
+					isExpo: expoServer,
 					available
 				});
 				if ("failed" in plan) return fail({
@@ -689,20 +717,20 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 							}
 							const handoffRecord = {
 								pid: child.pid,
-								processToken: child.pid ? (0, process_identity_exports.captureProcessToken)(child.pid) : null,
+								processToken: child.recordedIdentity ? child.recordedIdentity.processToken ?? null : child.pid ? (0, process_identity_exports.captureProcessToken)(child.pid) : null,
 								port,
-								mode: isExpo ? "expo-child" : "bare-inproc",
+								mode: serverMode,
 								startedAt: new Date(spawnedTs ?? Date.now()).toISOString()
 							};
 							try {
 								d.writeSupervisorRecord(root, { supervisor: handoffRecord });
 							} catch {
 								if (!await waitForSupervisorHandoff(child)) {
-									const stopped = await d.terminateSupervisorChild(child);
+									const stopped = supervisorSignalable(child) && await d.terminateSupervisorChild(child);
 									return { failed: {
 										code: "STIM_SUPERVISOR_EXITED",
 										message: `Could not record supervisor pid ${child.pid ?? "unknown"} before releasing the managed start lock.`,
-										remedy: stopped ? "The supervisor process was stopped. Retry `stim start --remote`." : `Cleanup failed. Unmanaged supervisor pid ${child.pid ?? "unknown"} may still be running. Stop it before retrying.`
+										remedy: stopped ? "The supervisor process was stopped. Retry `stim start --remote`." : `Cleanup failed. Unmanaged supervisor pid ${child.pid ?? "unknown"} may still be running. Stop it with \`stim stop\`${child.pid === void 0 ? "" : `, or \`${d.platform === "win32" ? `taskkill /PID ${child.pid} /T /F` : `kill ${child.pid}`}\``} before retrying.`
 									} };
 								}
 							}
@@ -959,12 +987,12 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		};
 	}
 }
-async function resolvePort(root, note, fail) {
-	const result = await resolveWorkspaceMetroPort(root, note, "start");
+async function resolvePort(root, settings, note, fail) {
+	const result = await resolveWorkspaceMetroPort(root, settings, note, "start");
 	return typeof result === "number" ? result : fail(result);
 }
-async function resolveWorkspaceMetroPort(root, note, command, reserve = true) {
-	const setting = metroPortSetting(root);
+async function resolveWorkspaceMetroPort(root, settings, note, command, reserve = true) {
+	const setting = metroPortSetting(settings);
 	if (setting.error) return {
 		code: "STIM_BAD_ARG",
 		message: setting.error,
@@ -973,7 +1001,7 @@ async function resolveWorkspaceMetroPort(root, note, command, reserve = true) {
 	const pinned = setting.port;
 	const project = getProject(root);
 	const recorded = project?.metroPort;
-	if (pinned === null && command === "web") return recorded ?? await reserveMetroPort(root);
+	if (pinned === null && command === "web") return recorded ?? await reservePort(root, null);
 	if (recorded) {
 		const supervisor = resolveSupervisorTarget({
 			state: readWorkspaceState$1(root)?.supervisor,
@@ -1005,17 +1033,25 @@ async function resolveWorkspaceMetroPort(root, note, command, reserve = true) {
 	} else if (recorded) {
 		const held = await resolveProjectMetro(recorded, root);
 		if (!held.notOurs) return recorded;
-		const fresh = await reserveMetroPort(root);
-		if (fresh !== recorded) {
+		const fresh = await reservePort(root, null);
+		if (typeof fresh === "number" && fresh !== recorded) {
 			note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
 			note(chalk.dim(`Reserved port ${fresh} for this project instead.`));
 		}
 		return fresh;
 	}
 	if (!reserve && pinned !== null) return pinned;
+	return reservePort(root, pinned);
+}
+async function reservePort(root, pinned) {
 	try {
 		return await reserveMetroPort(root, void 0, void 0, pinned);
 	} catch (error) {
+		if (error instanceof PortInspectionError) return {
+			code: error.code,
+			message: error.reason,
+			remedy: PORT_INSPECTION_REMEDY
+		};
 		return {
 			code: "STIM_BAD_ARG",
 			message: error.message,
@@ -1078,4 +1114,4 @@ function report({ json, out, facts, waited, reclaimed, links }) {
 	if (links) console.error(chalk.dim(workspaceLinkLine(links)));
 }
 //#endregion
-export { registerStart as a, startDevServer as c, tailLines as d, wantsExpoOwnTunnel as f, detectBundleId as h, readLogTail as i, startFacts as l, detectAppIds as m, liveSupervisor as n, resolveWorkspaceMetroPort as o, detectAndroidPackage as p, parseWait as r, startCommand as s, failureEvidence as t, supervisorEntry as u };
+export { registerStart as a, startDevServer as c, supervisorSignalable as d, tailLines as f, detectBundleId as g, detectAppIds as h, readLogTail as i, startFacts as l, detectAndroidPackage as m, liveSupervisor as n, resolveWorkspaceMetroPort as o, wantsExpoOwnTunnel as p, parseWait as r, startCommand as s, failureEvidence as t, supervisorEntry as u };

package/dist/{state-xnqpx3AD.mjs → state-Boo0IMJq.mjs}

@@ -1,11 +1,13 @@
 import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState$1, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1, w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { readMacosRecord } from "@stim-cli/core/state";
 //#region src/macos/state.ts
 const macosDir = (root) => join(workspaceDir(root), "macos");
 const macosLogFile = (root) => join(workspaceLogsDir$1(root), "macos.ndjson");
 const macosRuntimeClaim = (root) => join(macosDir(root), "runtime.lock");
+const macosAppPresent = (root) => readWorkspaceState$1(root)?.macos !== void 0 || existsSync(macosDir(root));
 function macosProcess(pid) {
 	const processToken = (0, process_identity_exports.captureProcessToken)(pid);
 	const start = (0, process_identity_exports.processStartMicros)(pid);
@@ -38,4 +40,4 @@ function updateMacosRecord(root, owner, patch) {
 	return updated;
 }
 //#endregion
-export { requiredMacosRecord as a, macosRuntimeClaim as i, macosLogFile as n, updateMacosRecord as o, macosProcess as r, macosDir as t };
+export { macosRuntimeClaim as a, macosProcess as i, macosDir as n, requiredMacosRecord as o, macosLogFile as r, updateMacosRecord as s, macosAppPresent as t };

package/dist/{state-BG-aAk4k.mjs → state-DI84A-uu.mjs}

@@ -1,11 +1,12 @@
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { o as pidExists } from "./metro-Dh8T4Ytd.mjs";
-import { a as updateWorkspaceState, c as writeWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { a as updateWorkspaceState, c as writeWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { s as pidExists } from "./metro-D_j9sN-B.mjs";
 import { readFileSync, readlinkSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { WEB_VIEWPORTS } from "@stim-cli/core/state";
-import { hostname } from "node:os";
 import { rotatedLogPath } from "@stim-cli/core";
+import { hostname } from "node:os";
 //#region src/web/profile.ts
 const SINGLETON_FILES = [
 	"SingletonLock",
@@ -32,17 +33,35 @@ function liveProfileHolder(profile, { alive = pidExists } = {}) {
 function removeSingletonFiles(profile) {
 	for (const name of SINGLETON_FILES) rmSync(join(profile, name), { force: true });
 }
+/** Whether a process in group `pgid` in a `ps -o pgid=,command=` listing has `profile` as its Chrome user data dir. */
+function groupRunsProfile(listing, pgid, profile) {
+	const flag = `--user-data-dir=${profile}`;
+	return listing.split("\n").some((line) => {
+		const row = /^\s*(\d+)\s+(.*)$/.exec(line);
+		if (!row || Number(row[1]) !== pgid) return false;
+		const at = row[2].indexOf(flag);
+		return at !== -1 && (row[2].length === at + flag.length || row[2][at + flag.length] === " ");
+	});
+}
 /**
-* Whether the owned Chrome still runs. `lingering` means the recorded process exited but its process group, whose
-* id is that pid, still has helper processes: a live group id cannot be reused. A pid now held by a different
-* process is `gone`, never something to signal.
+* Whether the owned Chrome still runs. `lingering` means the recorded process exited but a process of its group,
+* whose id is that pid, still runs Chrome on `profile`. A group id stays reserved only while the original group
+* lives, so a live group whose members do not run on the profile is `gone`, never something to signal, and so is a
+* pid now held by a different process.
 */
-function chromeProcessState(record) {
+function chromeProcessState(record, profile) {
 	const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
 	if (identity === "same") return "running";
 	if (identity === "unknown") return "unknown";
-	if (identity === "different") return "gone";
-	return (0, ownership_claim_exports.processGroupAlive)(record.pid) ? "lingering" : "gone";
+	if (identity === "different" || !(0, ownership_claim_exports.processGroupAlive)(record.pid)) return "gone";
+	const listing = getExecutor().runFileQuiet("ps", [
+		"-A",
+		"-ww",
+		"-o",
+		"pgid=,command="
+	]);
+	if (listing === null) return "unknown";
+	return groupRunsProfile(listing, record.pid, profile) ? "lingering" : "gone";
 }
 //#endregion
 //#region src/web/state.ts
@@ -132,7 +151,7 @@ function cdpEndpoint(port) {
 function webFacts(record) {
 	if (!record) return null;
 	const supervisor = (0, process_identity_exports.inspectProcessIdentity)(record);
-	const chrome = record.chromeProcess ? chromeProcessState(record.chromeProcess) : "gone";
+	const chrome = record.chromeProcess ? chromeProcessState(record.chromeProcess, record.profile) : "gone";
 	if (supervisor === "unknown" || chrome === "unknown") return {
 		record,
 		status: "unverified"

package/dist/{stats-DY6ekz8F.mjs → stats-BIIDrjA8.mjs}

@@ -1,8 +1,8 @@
-import { o as formatLongDuration } from "./command-output-CBtzyIgF.mjs";
-import { j as formatBytes } from "./config-CgYMahz7.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-CsKYexJM.mjs";
-import { s as findProjectRoot$1 } from "./project-C3ChRLZy.mjs";
-import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-CZ66YA4T.mjs";
+import { j as formatBytes } from "./config-D0LhTY3S.mjs";
+import { Et as repoRoot, mt as gitCommonDir } from "./settings-Bbztm4oV.mjs";
+import { o as formatLongDuration } from "./command-output-BjPN99ZB.mjs";
+import { r as findProjectRoot } from "./project-B8_duAzW.mjs";
+import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-DVyv_hWj.mjs";
 import { archivedUsage, readArchives, readStatsReport, statsProjectKey } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/stats.ts
@@ -13,7 +13,7 @@ function statsCommand(program) {
 	program.command("stats").description("Show how many `ios` and `android` runs this project and this machine have recorded, how many hit the build cache, and an estimate of the time that cache saved.").option("--json", "print the aggregates as JSON").action(async (opts) => {
 		const agentDevice = await getAgentDeviceUsage();
 		const swiftpmCache = await getSwiftpmCacheUsage();
-		const root = findProjectRoot$1(process.cwd());
+		const root = findProjectRoot(process.cwd());
 		const key = root ? statsProjectKey({
 			root,
 			commonDir: gitCommonDir(root),

package/dist/{status-BEeL6IKz.mjs → status-BDGHwkCs.mjs}

@@ -1,3 +1,4 @@
+import { j as formatBytes } from "./config-D0LhTY3S.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
 import { maintenanceRunClaims, readMaintenanceState } from "@stim-cli/core/state";
 import { claimRemoveCommand, readClaimSet } from "@stim-cli/core/ownership-claim";
@@ -41,7 +42,8 @@ function maintenanceLine(status, includeLabel = true) {
 	const outputs = status.plan.filter((action) => action.kind === "would-clear-outputs");
 	const summary = status.mode === "on" && status.lastPass ? `${status.lastPass.actions} actions, ${(status.lastPass.freedBytes / 1024 ** 3).toFixed(1)} GB freed` : 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" : status.mode}): ` : ""}${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}` : ""}`;
+	const culprits = (status.mode === "off" ? void 0 : status.pressure?.memory.culprits)?.map((culprit) => `${culprit.name} uses ${formatBytes(culprit.bytes)}${culprit.command ? ` (\`${culprit.command}\`)` : ""}`).join(", ");
+	return `${includeLabel ? `Auto maintenance (${status.mode === "report" ? "report only" : status.mode}): ` : ""}${at ? `${at}: ` : ""}${status.lastPass ? summary : "no pass has run yet"}${disk ? `; ${disk}` : ""}${culprits ? `; memory: ${culprits}` : ""}${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);