stim 1.23.0 → 1.24.0

package/dist/{server-expo-D9lEz4aq.mjs → server-expo-Tt_hLRpy.mjs}

@@ -1,14 +1,13 @@
-import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { o as cancellableSleep, t as getExecutor } from "./exec-VFRpu1iA.mjs";
 import { n as stripAnsi, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
-import { q as resolveProjectSettings } from "./settings-C7O8A6ZI.mjs";
-import { C as resolvePackageJson } from "./project-CTLNHCfE.mjs";
+import { q as resolveProjectSettings } from "./settings-RKwY33wv.mjs";
+import { C as resolvePackageJson } from "./project-Dz-hWkb-.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
 import { a as expoMetroStoreEnv, c as registerMetroStore, f as resolveMetroSharedCache, i as expoMetroConfigPath, n as supervisorError, o as metroStoreConfirmedRoot, s as metroStoreRoot } from "./errors-ccaPc4ox.mjs";
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
 import { LOG_ROTATE_BYTES } from "@stim-cli/core";
-import { projectNodeBin, satisfiesNodePin } from "@stim-cli/core/toolchain";
+import { meetsNodePinMajor, projectNodeBin, projectNodePin, resolveNodePinSpec, satisfiesNodePin } from "@stim-cli/core/toolchain";
 //#region src/supervisor/child-server.ts
 function superviseChildServer({ mode, child, log, toRecord, signal, alive = null, killTimeoutMs, onRecord = null }) {
 	let lastMsg = null;
@@ -86,6 +85,7 @@ function superviseChildServer({ mode, child, log, toRecord, signal, alive = null
 }
 //#endregion
 //#region src/supervisor/project-node.ts
+/** The version of the `node` that `env`'s `PATH` runs. */
 function pathNodeVersion(env) {
 	const childEnv = {};
 	for (const [key, value] of Object.entries(env)) if (value !== void 0) childEnv[key] = value;
@@ -95,18 +95,20 @@ function pathNodeVersion(env) {
 	});
 }
 /**
-* `env` with the Node that `root` pins (`.nvmrc`, `.node-version`, `.tool-versions` or Volta) first on `PATH`,
-* for the dev server Stim starts through its `#!/usr/bin/env node` script. It changes nothing when the project pins
-* no Node, when no installed Node satisfies the pin, or when the `node` already on `PATH` satisfies it.
+* `env` with the Node `projectNodeBin` picks for the pin in `root`, or the nearest directory above it up to `top`
+* (`.nvmrc`, `.node-version`, `.tool-versions` or Volta), first on `PATH`, for the processes Stim starts that run the
+* project's own Node code. It changes nothing when the project pins no Node, when no install fits the pin, or when
+* the `node` already on `PATH` satisfies it: matching the pin, or, when no install matches it, of its major and not
+* older than it.
 */
-function withProjectNode(root, env, { nodeVersion = pathNodeVersion } = {}) {
-	const pinned = projectNodeBin(root, env);
+function withProjectNode(root, env, { nodeVersion = pathNodeVersion, top = root } = {}) {
+	const pinned = projectNodeBin(root, env, void 0, top);
 	if (!pinned) return {
 		env,
 		pinned: null
 	};
 	const current = nodeVersion(env);
-	if (current && satisfiesNodePin(current, pinned.spec)) return {
+	if (current && (satisfiesNodePin(current, pinned.spec) || pinned.match === "major" && meetsNodePinMajor(current, pinned.spec))) return {
 		env,
 		pinned: null
 	};
@@ -118,6 +120,24 @@ function withProjectNode(root, env, { nodeVersion = pathNodeVersion } = {}) {
 		pinned
 	};
 }
+/**
+* Why the project's own Node code may have failed under `env`: the pin that `root`, or the nearest directory above it
+* up to `top`, sets when neither an install nor the `node` on `PATH` fits it as `withProjectNode` decides, else null.
+*/
+function unmetNodePin(root, env, { nodeVersion = pathNodeVersion, top = root } = {}) {
+	const pin = projectNodePin(root, void 0, top);
+	if (!pin || projectNodeBin(root, env, void 0, top)) return null;
+	const spec = resolveNodePinSpec(pin.spec, env);
+	const current = nodeVersion(env) ?? "unknown";
+	if (!spec) return `Stim cannot resolve ${pin.file} ${pin.spec} through nvm's aliases, so Node ${current} on PATH ran.`;
+	if (satisfiesNodePin(current, spec) || meetsNodePinMajor(current, spec)) return null;
+	return `Node ${current} on PATH does not satisfy ${pin.file} ${pin.spec}, and no installed Node does.`;
+}
+/** The log line naming the Node `withProjectNode` put first on `PATH` and the pin it stands for. */
+function projectNodeLine(pinned) {
+	const line = `Node ${pinned.version} from ${pinned.bin}, for ${pinned.pin} ${pinned.spec}`;
+	return pinned.match === "major" ? `${line} (no install has ${pinned.spec}; the newest ${pinned.version.split(".")[0]}.x not older than it)` : line;
+}
 //#endregion
 //#region src/supervisor/server-expo.ts
 function resolveExpoBin(root) {
@@ -253,6 +273,9 @@ function expoProxyEnv(env) {
 	const publicUrl = env.STIM_METRO_PUBLIC_URL?.trim();
 	return publicUrl ? { EXPO_PACKAGER_PROXY_URL: publicUrl.replace(/\/+$/, "") } : {};
 }
+function expoTelemetryEnv(env) {
+	return env.EXPO_NO_TELEMETRY === void 0 ? { EXPO_NO_TELEMETRY: "1" } : {};
+}
 const WAITING_ON_RE = /^Waiting on (\S+)/;
 const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 const HTTP_SCHEME_RE = /^https?:\/\//i;
@@ -335,7 +358,7 @@ async function startExpoServer({ root, port, logsDir, writer = null, spawnFn = n
 		src: "metro",
 		level: "info",
 		event: "project_node",
-		msg: `Metro runs on Node ${node.pinned.version} from ${node.pinned.bin}, which ${node.pinned.pin} pins`
+		msg: `Metro runs on ${projectNodeLine(node.pinned)}`
 	});
 	const child = spawn(command, commandArgs, {
 		cwd: root,
@@ -349,6 +372,7 @@ async function startExpoServer({ root, port, logsDir, writer = null, spawnFn = n
 			...node.env,
 			FORCE_COLOR: "0",
 			...expoProxyEnv(process.env),
+			...expoTelemetryEnv(process.env),
 			...storeEnv,
 			...tunnel ? { EXPO_UNSTABLE_TUNNEL_V2: "1" } : {}
 		}
@@ -372,4 +396,4 @@ async function startExpoServer({ root, port, logsDir, writer = null, spawnFn = n
 	});
 }
 //#endregion
-export { expoProxyEnv as a, inferLevel as c, parseExpoWaitingOnUrl as d, recordFromLine as f, superviseChildServer as h, expoBinRefusal as i, isBundleMarker as l, withProjectNode as m, expoBinFromPackage as n, expoSdkMajor as o, startExpoServer as p, expoBinPath as r, findBinUpward as s, cleanLine as t, isDevClientNavigationNotice as u };
+export { unmetNodePin as _, expoProxyEnv as a, findBinUpward as c, isDevClientNavigationNotice as d, parseExpoWaitingOnUrl as f, projectNodeLine as g, pathNodeVersion as h, expoBinRefusal as i, inferLevel as l, startExpoServer as m, expoBinFromPackage as n, expoSdkMajor as o, recordFromLine as p, expoBinPath as r, expoTelemetryEnv as s, cleanLine as t, isBundleMarker as u, withProjectNode as v, superviseChildServer as y };

package/dist/{settings-C7O8A6ZI.mjs → settings-RKwY33wv.mjs}

@@ -1,12 +1,13 @@
-import { n as isTimeoutError, r as WorkspaceProcessCleanupError, t as getExecutor } from "./exec-DEoAhcze.mjs";
-import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-DlrsduwG.mjs";
-import { c as gitQuiet, f as throwIfCancelled, l as gitQuietAsync, o as git, r as childEnvironment, s as gitAsync } from "./operation-exec-BW0em61G.mjs";
+import { c as throwIfCancelled, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-VFRpu1iA.mjs";
+import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-BZhXY15H.mjs";
+import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-CUZifp6Z.mjs";
 import { accessSync, chmodSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { ambientEnv, buildCacheRoot } from "@stim-cli/core";
+import { ambientEnv, buildCacheRoot, compiledHelper, configDir } from "@stim-cli/core";
 import { REMOTE_DEVICE_BACKENDS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, WEB_VIEWPORTS, acceptsShape, coerceSettingText, expectedShape, isLayeredSetting, settingDefinition, settingValueError } from "@stim-cli/core/state";
 import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, normalize, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { fileURLToPath } from "node:url";
 import { existsSync as existsSync$1, lstatSync as lstatSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1 } from "fs";
 import { chmod, lstat, mkdir, readdir, rm, utimes } from "node:fs/promises";
 //#region src/temporary.ts
@@ -107,6 +108,51 @@ async function removeTemporaryEntryAsync(path, signal) {
 	signal?.throwIfAborted();
 }
 //#endregion
+//#region src/clonefile.ts
+const SOURCE = "stim-clonefile.c";
+const COMPILE_TIMEOUT_MS = 12e4;
+const PROBE_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);
+}
+/** The `stim-clonefile` helper, compiled on first use, or null off macOS, without the Command Line Tools, or when the compile fails. */
+async function clonefileHelper(operation) {
+	if (process.platform !== "darwin") return null;
+	const exec = getExecutor();
+	if (!await runOperationFileQuiet(operation, exec, "xcode-select", ["-p"], {
+		timeoutMs: PROBE_TIMEOUT_MS,
+		cwd: operation.cwd
+	})) return null;
+	const source = helperSource();
+	try {
+		return await compiledHelper({
+			dir: join(configDir(), "helpers"),
+			name: "stim-clonefile",
+			inputs: [source],
+			version: "",
+			prune: false,
+			compile: async (output) => {
+				await runOperationFile(operation, exec, "xcrun", [
+					"clang",
+					"-O2",
+					"-o",
+					output,
+					source
+				], {
+					timeoutMs: COMPILE_TIMEOUT_MS,
+					cwd: operation.cwd
+				});
+			}
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation.signal.throwIfAborted();
+		return null;
+	}
+}
+//#endregion
 //#region src/workspace/worktree.ts
 const CARRY_SKIP_BASENAMES = /* @__PURE__ */ new Set([
 	".DerivedData",
@@ -121,7 +167,7 @@ function isCarrySkipped(rel) {
 function nativePath(path) {
 	return sep$1 === "/" ? path : path.replaceAll("/", sep$1);
 }
-async function gitReadAsync(dir, args, { removal, env, signal, declareFor, untrimmed }) {
+async function gitReadAsync(dir, args, { removal, timeoutThrows, env, signal, declareFor, untrimmed }) {
 	signal ??= getExecutor().reportSignal?.();
 	try {
 		return await gitAsync(dir, args, {
@@ -135,7 +181,7 @@ async function gitReadAsync(dir, args, { removal, env, signal, declareFor, untri
 	} catch (error) {
 		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 		signal?.throwIfAborted();
-		if (removal && isTimeoutError(error)) throw error;
+		if ((removal || timeoutThrows) && isTimeoutError(error)) throw error;
 		return null;
 	}
 }
@@ -213,7 +259,8 @@ async function warmWorktreePaths(cwd, operation) {
 	const options = {
 		env: operation?.env,
 		signal: operation?.signal,
-		declareFor: operation
+		declareFor: operation,
+		timeoutThrows: true
 	};
 	const currentRoot = await repoRootAsync(cwd, options);
 	if (!currentRoot) throw new Error("Not a git repository.");
@@ -334,7 +381,8 @@ function missingDestinationReason(target, rel) {
 	}
 	return lstatSync$1(join$1(target, rel), { throwIfNoEntry: false }) ? "exists" : null;
 }
-async function removeCopiedExclusionsAsync(path, rel, signal) {
+const SWEEP_CONCURRENCY = 32;
+async function removeExclusionsIn({ path, rel }, signal) {
 	signal.throwIfAborted();
 	const entries = await readdir(path, { withFileTypes: true });
 	const excluded = entries.filter((entry) => isCarrySkipped(`${rel}/${entry.name}`));
@@ -351,10 +399,48 @@ async function removeCopiedExclusionsAsync(path, rel, signal) {
 			await chmod(path, stat.mode);
 		}
 	}
+	const children = [];
 	for (const entry of entries) {
 		const child = `${rel}/${entry.name}`;
-		if (entry.isDirectory() && !isCarrySkipped(child)) await removeCopiedExclusionsAsync(join$1(path, entry.name), child, signal);
+		if (entry.isDirectory() && !isCarrySkipped(child)) children.push({
+			path: join$1(path, entry.name),
+			rel: child
+		});
 	}
+	return children;
+}
+async function removeCopiedExclusionsAsync(path, rel, signal) {
+	let active = 0;
+	const waiting = [];
+	const acquire = async () => {
+		if (active < SWEEP_CONCURRENCY) active += 1;
+		else await new Promise((wake) => waiting.push(wake));
+	};
+	const release = () => {
+		const next = waiting.shift();
+		if (next) next();
+		else active -= 1;
+	};
+	let failure;
+	const visit = async (directory) => {
+		await acquire();
+		let children;
+		try {
+			if (failure) return;
+			children = await removeExclusionsIn(directory, signal);
+		} catch (error) {
+			failure ??= { error };
+			return;
+		} finally {
+			release();
+		}
+		await Promise.all(children.map(visit));
+	};
+	await visit({
+		path,
+		rel
+	});
+	if (failure) throw failure.error;
 }
 async function cloneIgnoredEntries({ root, target, patterns, operation }) {
 	const options = {
@@ -377,6 +463,8 @@ async function cloneIgnoredEntries({ root, target, patterns, operation }) {
 	const skipped = [];
 	const failed = [];
 	let cloned = true;
+	let helper;
+	const clonefile = () => helper ??= clonefileHelper(operation);
 	for (const rel of entries) {
 		operation.signal.throwIfAborted();
 		const from = join$1(root, rel);
@@ -393,16 +481,23 @@ async function cloneIgnoredEntries({ root, target, patterns, operation }) {
 			}
 			await mkdir(dirname$1(to), { recursive: true });
 			copying = true;
-			try {
-				await getExecutor().runFileAsync("cp", [
-					"-Rc",
-					from,
-					to
-				], options);
-			} catch (cause) {
-				if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
-				operation.signal.throwIfAborted();
-				await removeTemporaryEntryAsync(to);
+			const copiedWith = async (file, args) => {
+				try {
+					await getExecutor().runFileAsync(file, args, options);
+					return true;
+				} catch (cause) {
+					if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
+					operation.signal.throwIfAborted();
+					await removeTemporaryEntryAsync(to);
+					return false;
+				}
+			};
+			const directoryClone = (await lstat(from)).isDirectory() ? await clonefile() : null;
+			if (!(directoryClone && await copiedWith(directoryClone, [from, to])) && !await copiedWith("cp", [
+				"-Rc",
+				from,
+				to
+			])) {
 				await getExecutor().runFileAsync("cp", [
 					"-R",
 					from,

package/dist/{settings-eKF_vJJs.mjs → settings-kkt0vP4w.mjs}

@@ -1,4 +1,4 @@
-import { a as layerFile, c as settingEntry, i as SettingsRefusal, n as readScope, o as readSettingsContext, r as requireSetting, s as readSettingsPayload, t as mutateSetting } from "./settings-write-79mQRr9C.mjs";
+import { a as layerFile, c as settingEntry, i as SettingsRefusal, n as readScope, o as readSettingsContext, r as requireSetting, s as readSettingsPayload, t as mutateSetting } from "./settings-write--gj6MACV.mjs";
 import { SETTING_SCOPES } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/settings.ts

package/dist/{settings-write-79mQRr9C.mjs → settings-write--gj6MACV.mjs}

@@ -1,10 +1,10 @@
-import { i as withWorkspaceProcessLock } from "./exec-DEoAhcze.mjs";
-import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-DlrsduwG.mjs";
-import { a as killOnAbort, i as gitPath } from "./operation-exec-BW0em61G.mjs";
-import { it as unknownSettingKeys, z as readCommittedSettings } from "./settings-C7O8A6ZI.mjs";
-import { r as findCommandWorkspaceAsync, t as NO_PROJECT_REFUSAL } from "./project-CTLNHCfE.mjs";
-import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-D5OGpYZM.mjs";
-import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-CQmfzAh7.mjs";
+import { u as withWorkspaceProcessLock } from "./exec-VFRpu1iA.mjs";
+import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-BZhXY15H.mjs";
+import { a as killOnAbort, i as gitPath } from "./operation-exec-CUZifp6Z.mjs";
+import { it as unknownSettingKeys, z as readCommittedSettings } from "./settings-RKwY33wv.mjs";
+import { r as findCommandWorkspaceAsync, t as NO_PROJECT_REFUSAL } from "./project-Dz-hWkb-.mjs";
+import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-DS0mzR8U.mjs";
+import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-CdPwYwvs.mjs";
 import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { configDir } from "@stim-cli/core";

package/dist/settings.schema.json

@@ -2361,6 +2361,19 @@
                 ]
               }
             },
+            "easMaxDurationMinutes": {
+              "description": "Maximum minutes of each EAS Simulator session Stim creates, after which EAS stops it and stops billing; stim stop and gc --delete end a session sooner. EAS rejects a value above the account plan's session limit",
+              "type": "integer",
+              "minimum": 1,
+              "default": 30,
+              "x-stim": {
+                "key": "remote.easMaxDurationMinutes",
+                "kind": "number",
+                "scopes": [
+                  "machine"
+                ]
+              }
+            },
             "build": {
               "description": "Build placement: auto follows remote.buildMode within enabled automatic pool members; local always builds here; a name in remote.machines requires that remote machine without fallback. The ios, android and macos --remote-build flag overrides this setting and its environment override",
               "type": "string",

package/dist/{simslim-BNckWpXi.mjs → simslim-CdWKT3vA.mjs}

@@ -1,5 +1,5 @@
-import { g as process_identity_exports, m as operationState, p as isTermination, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
-import { d as getConfigDir } from "./config-DlrsduwG.mjs";
+import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, t as getExecutor, y as isTermination } from "./exec-VFRpu1iA.mjs";
+import { d as getConfigDir } from "./config-BZhXY15H.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
 import { join } from "node:path";
 //#region src/engine/simslim.ts

package/dist/{slot-launch-D7M2nE4b.mjs → slot-launch-A1BgotaM.mjs}

@@ -1,9 +1,9 @@
-import { G as projectDeviceSlots, U as parseDeviceSlotKey, p as getProject } from "./config-DlrsduwG.mjs";
-import { r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
-import { gn as deviceShellArg } from "./budget-DnPX3DXj.mjs";
-import { y as fileLeaseIo } from "./activity-B5RtpFda.mjs";
-import { O as getAvdNameForSerialAsync, j as listAdbDevicesAsync } from "./android-C7sVmyI9.mjs";
-import { f as listAllIosSimsAsync } from "./ios-hcBpnEGk.mjs";
+import { G as projectDeviceSlots, U as parseDeviceSlotKey, p as getProject } from "./config-BZhXY15H.mjs";
+import { r as readWorkspaceState$1 } from "./workspace-state-CeBpIZgr.mjs";
+import { O as getAvdNameForSerialAsync, j as listAdbDevicesAsync } from "./android-882m4hxX.mjs";
+import { vn as deviceShellArg } from "./budget-dPGuhNai.mjs";
+import { y as fileLeaseIo } from "./activity-Dq3ZcdD8.mjs";
+import { f as listAllIosSimsAsync } from "./ios-CVUFFZ6C.mjs";
 import { hostedNativeRecords } from "@stim-cli/core/state";
 //#region src/engine/slot-launch.ts
 function launchSlotScope(root, slot = "default") {

package/dist/{stage-DKNM4ZPd.mjs → stage-ERTMh88n.mjs}

@@ -1,6 +1,5 @@
-import { h as withDrainingCancellation, t as getExecutor } from "./exec-DEoAhcze.mjs";
-import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
-import { d as runCancellationSignal } from "./native-run-BUTu8T7A.mjs";
+import { c as throwIfCancelled, t as getExecutor, x as withDrainingCancellation } from "./exec-VFRpu1iA.mjs";
+import { d as runCancellationSignal } from "./native-run-BmH7U8pr.mjs";
 import { existsSync, lstatSync, promises, readdirSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { validMacosResourceDestination } from "@stim-cli/core";

package/dist/{start-bjfiScgz.mjs → start-BKGrEhzG.mjs}

@@ -1,18 +1,17 @@
-import { a as workspaceProcessLockError, g as process_identity_exports, h as withDrainingCancellation, i as withWorkspaceProcessLock, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { D as ownership_claim_exports, S as process_identity_exports, a as waitForGroupExit, c as throwIfCancelled, d as workspaceProcessLockError, l as WorkspaceProcessCleanupError, o as cancellableSleep, r as groupExitBudgetMs, t as getExecutor, u as withWorkspaceProcessLock, x as withDrainingCancellation } from "./exec-VFRpu1iA.mjs";
 import { l as workspaceAgentDeviceDir, m as workspaceLogsDir$1, n as ensureWorkspaceStorage, s as supervisorLogFile } from "./paths-DQtTgsBf.mjs";
-import { E as upsertProject, O as withConfigLockAsync$1, p as getProject } from "./config-DlrsduwG.mjs";
-import { _ as stepTimer, l as phaseLine } from "./command-output-Db8BqzxH.mjs";
-import { f as throwIfCancelled, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
-import { i as recordWorkspaceUse, l as withWorkspaceStateLockAsync, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-U08dEzhG.mjs";
-import { A as metroIdleStopMinutesSetting, G as resolveCacheProviderConfig, J as resolveProjectSettingsAsync, K as resolveIosProjectDir, M as metroTunnelSettingError, O as metroCommandSetting, P as ngrokUrlSetting, R as publicUrlSetting, U as remoteIosSetting, V as remoteAndroidSetting, W as resolveAndroidLayout, a as SETTING_SHAPE_REMEDY, ct as detectProviders, et as settingShapeErrors, h as deviceIdleShutdownMinutesSetting, it as unknownSettingKeys, j as metroPortSetting, k as metroCommandSettingError, lt as planMetroReach, m as defaultAndroidLayout, p as cacheProviderSettingError, rt as tunnelModeSetting, st as PUBLIC_METRO_ENV } from "./settings-C7O8A6ZI.mjs";
-import { E as MODE_EXPO, M as readMetroTunnel, O as clearManagedMetroTunnel, S as readAppJson, T as MODE_COMMAND, c as projectProblem, i as findProjectRoot$1, t as NO_PROJECT_REFUSAL, v as detectIsExpo, w as MODE_BARE, x as readAppConfigText } from "./project-CTLNHCfE.mjs";
+import { E as upsertProject, O as withConfigLockAsync$1, p as getProject, x as releaseMetroPort } from "./config-BZhXY15H.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-DxC0k2rk.mjs";
+import { i as recordWorkspaceUse, l as withWorkspaceStateLockAsync, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-CeBpIZgr.mjs";
+import { A as metroIdleStopMinutesSetting, G as resolveCacheProviderConfig, J as resolveProjectSettingsAsync, K as resolveIosProjectDir, M as metroTunnelSettingError, O as metroCommandSetting, P as ngrokUrlSetting, R as publicUrlSetting, U as remoteIosSetting, V as remoteAndroidSetting, W as resolveAndroidLayout, a as SETTING_SHAPE_REMEDY, ct as detectProviders, et as settingShapeErrors, h as deviceIdleShutdownMinutesSetting, it as unknownSettingKeys, j as metroPortSetting, k as metroCommandSettingError, lt as planMetroReach, m as defaultAndroidLayout, p as cacheProviderSettingError, rt as tunnelModeSetting, st as PUBLIC_METRO_ENV } from "./settings-RKwY33wv.mjs";
+import { E as MODE_EXPO, M as readMetroTunnel, O as clearManagedMetroTunnel, S as readAppJson, T as MODE_COMMAND, c as projectProblem, i as findProjectRoot$1, t as NO_PROJECT_REFUSAL, v as detectIsExpo, w as MODE_BARE, x as readAppConfigText } from "./project-Dz-hWkb-.mjs";
+import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-DS0mzR8U.mjs";
+import { _ as PORT_INSPECTION_REMEDY, a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, f as signalProcessTree, g as reserveMetroPort, h as isMetroRunning, m as createPortProbe, u as processCwds, v as PortInspectionError } from "./metro-Bu8LBfzS.mjs";
 import { i as levelRank } from "./ndjson-CgE_o3Dl.mjs";
-import { _ as PORT_INSPECTION_REMEDY, a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, f as signalProcessTree, g as reserveMetroPort, h as isMetroRunning, u as processCwds, v as PortInspectionError } from "./metro-DiXtA3Ty.mjs";
-import { In as runProcessOperation, Kn as readProjectConfig, Pn as exitAfterFlush, Zn as remoteCliInvocation, p as stopOwnedMetroForReset, t as budgetGate } from "./budget-DnPX3DXj.mjs";
-import { _ as stopTunnel, g as startTunnelSequence, h as resolveSupervisorTarget, v as terminateChild, x as withManagedTunnelLock, y as withManagedRemoteWorktreeLock } from "./workspaces-BxzYlo3P.mjs";
-import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-D5OGpYZM.mjs";
+import { $n as remoteCliInvocation, In as exitAfterFlush, Jn as readProjectConfig, Rn as runProcessOperation, p as stopOwnedMetroForReset, t as budgetGate } from "./budget-dPGuhNai.mjs";
+import { S as withManagedTunnelLock, _ as startTunnelSequence, b as withManagedRemoteWorktreeLock, g as resolveSupervisorTarget, v as stopTunnel, y as terminateChild } from "./workspaces-CSV2Orf4.mjs";
 import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-BwNEtIrP.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-KmieOKgN.mjs";
 import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { ambientContext, ambientEnv } from "@stim-cli/core";
@@ -244,12 +243,11 @@ const DEFAULT_START_DEPS = {
 		if (child.pid && process.platform !== "win32") try {
 			signalProcessTree(child.pid, "SIGTERM", { group: true });
 		} catch {}
-		return terminateChild(child, {
+		return await terminateChild(child, {
 			alreadyExited: false,
 			timeoutMs: 1e3,
-			isAlive: pidExists,
-			waitForGroup: process.platform !== "win32"
-		});
+			isAlive: pidExists
+		}) && (process.platform === "win32" || !child.pid || await waitForGroupExit(child.pid, groupExitBudgetMs()));
 	},
 	withWorktreeLock: withManagedRemoteWorktreeLock,
 	withTunnelLock: withManagedTunnelLock,
@@ -372,7 +370,19 @@ var StartRefusal = class extends Error {
 		this.refusal = refusal;
 	}
 };
-async function startDevServer({ root, settings, settingsContext, waitSeconds = DEFAULT_WAIT_SECONDS, remote: remoteFlag = false, resetCache = false, out, note }, overrides = {}) {
+var MetroPortRace = class extends StartRefusal {
+	port;
+	constructor(refusal, port) {
+		super(refusal);
+		this.port = port;
+	}
+};
+const PORT_RACE_ATTEMPTS = 3;
+function portBindRace(lines, port) {
+	const bind = new RegExp(`EADDRINUSE\\b.*:${port}\\b`);
+	return lines.some((line) => bind.test(line));
+}
+async function startDevServer({ root, settings, settingsContext, waitSeconds = DEFAULT_WAIT_SECONDS, remote: remoteFlag = false, resetCache = false, hostedPorts, out, note }, overrides = {}) {
 	const d = {
 		...DEFAULT_START_DEPS,
 		...overrides
@@ -459,7 +469,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					const pid = child?.pid;
 					if (pid) {
 						const alive = () => d.platform === "win32" ? !identity || (0, process_identity_exports.inspectProcessIdentity)(identity) !== "gone" : (0, ownership_claim_exports.processGroupAlive)(pid);
-						const deadline = Date.now() + 1e3;
+						const deadline = Date.now() + groupExitBudgetMs();
 						while (alive() && Date.now() < deadline) await cancellableSleep(25);
 						if (alive()) throw new WorkspaceProcessCleanupError(claims, `Could not confirm cleanup of Expo config process ${pid}.`, "Inspect and stop the Expo config process and its helpers before retrying.");
 					}
@@ -482,7 +492,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					env: ambientEnv(),
 					signal: operationSignal
 				});
-				reclaimed = budget.reclaimed;
+				reclaimed = [...reclaimed, ...budget.reclaimed];
 				if (budget.refusal) return fail(budget.refusal);
 			};
 			if (resetCache) {
@@ -506,7 +516,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 			}
 			const logsDir = workspaceLogsDir$1(root);
 			const logFile = supervisorLogFile(root);
-			const port = await resolvePort(root, settings, note, fail);
+			const port = await resolvePort(root, settings, note, fail, hostedPorts);
 			let publicOrigin = remote ? publicUrl : null;
 			let resolution = await resolveStartupMetro(port, root);
 			let supervisor = liveSupervisor({
@@ -750,7 +760,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 							throw new WorkspaceProcessCleanupError(claims, `Supervisor pid ${child.pid} published ownership that cannot be reconciled with the workspace registry.`, "Inspect the supervisor and its dev server, then stop them with their original tooling before retrying.");
 						}
 						const same = spawnedIdentity && (0, process_identity_exports.inspectProcessIdentity)(spawnedIdentity) === "same";
-						const supervisorCleanup = childExit !== null && !(0, ownership_claim_exports.processGroupAlive)(child.pid) || Boolean(same && supervisorSignalable(child) && await d.terminateSupervisorChild(child));
+						const supervisorCleanup = childExit !== null && (same ? !(0, ownership_claim_exports.processGroupAlive)(child.pid) : await waitForGroupExit(child.pid, groupExitBudgetMs())) || Boolean(same && supervisorSignalable(child) && await d.terminateSupervisorChild(child));
 						const publicationRacedCleanup = hasPublishedSupervisor();
 						if (!supervisorCleanup || d.platform !== "win32" && (0, ownership_claim_exports.processGroupAlive)(child.pid) || publicationRacedCleanup) {
 							if (publicationRacedCleanup) for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
@@ -763,6 +773,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					throw new WorkspaceProcessCleanupError(claims, `Could not reconcile supervisor ownership: ${cause.message}`, "Inspect and stop the supervisor with its original tooling before retrying.");
 				}
 			};
+			let refusal;
 			try {
 				if (remote && !tunnel && !publicUrl && tunnelMode !== "off") {
 					const available = d.providers(tunnelMode);
@@ -1117,7 +1128,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					const gone = childExit !== null || (child.pid ? !pidExists(child.pid) : false);
 					const exitInfo = childExit;
 					const how = exitInfo ? exitInfo.signal ? `signal ${exitInfo.signal}` : `code ${exitInfo.code}` : "without being observed";
-					return fail(gone ? {
+					const failure = gone ? {
 						code: "STIM_SUPERVISOR_EXITED",
 						message: `The supervisor exited (${how}) before the dev server came up on port ${port}.`,
 						lines: failureEvidence({
@@ -1135,7 +1146,9 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 							sinceTs: attemptStartedTs
 						}),
 						remedy: "It may still be starting. Run `stim stop` to halt it, or `stim logs` to follow along."
-					});
+					};
+					if (gone && !remote && metroPortSetting(settings, ambientEnv()).port === null && portBindRace(failure.lines ?? [], port)) throw new MetroPortRace(failure, port);
+					return fail(failure);
 				}
 				if (managedTunnelExited()) return failExitedManagedTunnel();
 				if (tunnel) {
@@ -1165,13 +1178,36 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					logsDir,
 					alreadyRunning: false
 				});
+			} catch (error) {
+				if (error instanceof StartRefusal) refusal = error;
+				throw error;
 			} finally {
-				await reconcileSpawnedSupervisor();
+				await reconcileSpawnedSupervisor().catch((cleanup) => {
+					if (refusal && cleanup instanceof WorkspaceProcessCleanupError) {
+						cleanup.message = `${refusal.message} ${cleanup.message}`;
+						cleanup.cause = refusal;
+					}
+					throw cleanup;
+				});
+			}
+		};
+		const runStartRetryingPortRace = async (claim, tunnelClaim) => {
+			for (let attempt = 1;; attempt++) try {
+				return await runStart(claim, tunnelClaim);
+			} catch (error) {
+				if (!(error instanceof MetroPortRace)) throw error;
+				if (attempt === PORT_RACE_ATTEMPTS) throw new StartRefusal({
+					...error.refusal,
+					remedy: `Another process took port ${error.port} after Stim reserved it, ${PORT_RACE_ATTEMPTS} times in a row. Run \`stim start\` again; it reserves a free port.`
+				});
+				await withConfigLockAsync$1(() => releaseMetroPort(root, error.port), operationSignal);
+				note(chalk.yellow(`Port ${error.port} was taken by another process while the dev server started.`));
+				note(chalk.dim("Reserving another port and starting again."));
 			}
 		};
 		const startLocked = async () => {
 			try {
-				return await d.withTunnelLock(root, (tunnelClaim) => withWorkspaceProcessLock(dirname(workspaceLogsDir$1(root)), "metro-start", (claim) => runStart(claim, tunnelClaim), {
+				return await d.withTunnelLock(root, (tunnelClaim) => withWorkspaceProcessLock(dirname(workspaceLogsDir$1(root)), "metro-start", (claim) => runStartRetryingPortRace(claim, tunnelClaim), {
 					external: true,
 					signal: operationSignal
 				}), { signal: operationSignal });
@@ -1220,7 +1256,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 		if (error instanceof WorkspaceProcessCleanupError) return {
 			ok: false,
 			error: startError(error),
-			lines: [],
+			lines: error.cause instanceof StartRefusal ? error.cause.refusal.lines ?? [] : [],
 			reclaimed,
 			retainedClaimRoots: [...new Set(error.claims.map((claim) => claim.root))]
 		};
@@ -1233,11 +1269,11 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 		};
 	}
 }
-async function resolvePort(root, settings, note, fail) {
-	const result = await resolveWorkspaceMetroPort(root, settings, note, "start");
+async function resolvePort(root, settings, note, fail, hostedPorts) {
+	const result = await resolveWorkspaceMetroPort(root, settings, note, "start", true, hostedPorts);
 	return typeof result === "number" ? result : fail(result);
 }
-async function resolveWorkspaceMetroPort(root, settings, note, command, reserve = true) {
+async function resolveWorkspaceMetroPort(root, settings, note, command, reserve = true, hostedPorts) {
 	const setting = metroPortSetting(settings, ambientEnv());
 	if (setting.error) return {
 		code: "STIM_BAD_ARG",
@@ -1275,23 +1311,27 @@ async function resolveWorkspaceMetroPort(root, settings, note, command, reserve
 			message: `Port ${pinned} is held by something else (${held.notOurs}), and metro.port pins this workspace's Metro to it.`,
 			remedy: "Stop the process on that port, or set another metro.port."
 		};
+		if (hostedPorts && !held.metro && !await hostedPorts.free(pinned)) return hostedPorts.busy(pinned);
 		if (recorded === pinned) return recorded;
 	} else if (recorded) {
 		const held = await resolveStartupMetro(recorded, root);
-		if (!held.notOurs) return recorded;
-		const fresh = await reservePort(root, null);
+		const hostBusy = !held.notOurs && hostedPorts && !held.metro && !await hostedPorts.free(recorded) ? hostedPorts.machine : null;
+		if (!held.notOurs && !hostBusy) return recorded;
+		const fresh = await reservePort(root, null, hostedPorts);
 		if (typeof fresh === "number" && fresh !== recorded) {
-			note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
+			note(chalk.yellow(hostBusy ? `Port ${recorded} is in use on ${hostBusy}, where an Expo dev client loads its bundle from this workspace's Metro port.` : `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);
+	return reservePort(root, pinned, hostedPorts);
 }
-async function reservePort(root, pinned) {
+async function reservePort(root, pinned, hostedPorts) {
+	const local = hostedPorts && createPortProbe();
+	const isFree = local && (async (port) => await local(port) && await hostedPorts.free(port));
 	try {
-		return await reserveMetroPort(root, void 0, void 0, pinned, ambientContext()?.signal);
+		return await reserveMetroPort(root, void 0, isFree, pinned, ambientContext()?.signal);
 	} catch (error) {
 		throwIfCancelled(ambientContext()?.signal, "Metro startup");
 		if (error instanceof PortInspectionError) return {

package/dist/{start-CRfN1kWV.mjs → start-Bmg_qmHi.mjs}

@@ -1,2 +1,2 @@
-import { a as registerStart, c as startDevServer, d as supervisorSignalable, f as tailLines, i as readLogTail, l as startFacts, n as liveSupervisor, o as resolveWorkspaceMetroPort, p as wantsExpoOwnTunnel, r as parseWait, s as startCommand, t as failureEvidence, u as supervisorEntry } from "./start-bjfiScgz.mjs";
+import { a as registerStart, c as startDevServer, d as supervisorSignalable, f as tailLines, i as readLogTail, l as startFacts, n as liveSupervisor, o as resolveWorkspaceMetroPort, p as wantsExpoOwnTunnel, r as parseWait, s as startCommand, t as failureEvidence, u as supervisorEntry } from "./start-BKGrEhzG.mjs";
 export { startCommand as default, failureEvidence, liveSupervisor, parseWait, readLogTail, registerStart, resolveWorkspaceMetroPort, startDevServer, startFacts, supervisorEntry, supervisorSignalable, tailLines, wantsExpoOwnTunnel };