stim 1.20.2 → 1.22.0

package/dist/{build-plan-B7SZsc2N.mjs → eas-fallback-CSgAulr5.mjs}

@@ -1,23 +1,17 @@
-import { _ as loadConfig$1, p as getProject } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { Ft as makeTemporaryDirectory, It as removeTemporaryEntry, ot as detectProviders, st as planMetroReach } from "./settings-B717odTD.mjs";
-import { w as entryDir, y as artifactIn } from "./device-lease-BX1sJQ2E.mjs";
-import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { N as readRemoteSession, j as readMetroTunnel } from "./project-_phNIJfs.mjs";
-import { Mt as readStats$1, s as peekBudget, wt as estimateBuild } from "./budget-f7516Zk0.mjs";
-import { a as easAuthNote, f as resolveEasCliBin, s as isEasAuthFailureText } from "./remote-cache-OyOyVIS3.mjs";
-import { S as hostingMachines, h as namedBuildMachine, v as resolveBuildMachine } from "./client-qQAaXSUs.mjs";
-import { P as readHostMemoryPressure } from "./ios-RkW4pnQf.mjs";
-import { r as predictBuildMiss } from "./miss-reason-mKzZ4VvN.mjs";
-import { s as peekDeviceSlots } from "./device-capacity-CBUAcRyQ.mjs";
-import { c as connectHost, f as requireHostedAppMode, s as call } from "./hosted-client-ZEKpS9vw.mjs";
-import { r as readHostedNative, s as writeHostedNative } from "./ios-state-CBLe1xYw.mjs";
-import { n as prepareHostedNative } from "./hosted-native-A4s1QPXe.mjs";
-import { h as easCliSupport, m as MIN_EAS_CLI_SIMULATOR_VERSION, p as MIN_EAS_CLI_DEVICE_VERSION, s as readInstalledEasCliVersion } from "./device-remote-xRT0Vmo9.mjs";
-import { i as staleNativeDirRefusal } from "./prebuild-DYbucPXy.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { _ as loadConfig$1, p as getProject } from "./config-DlrsduwG.mjs";
+import { f as throwIfCancelled, r as childEnvironment } from "./operation-exec-BW0em61G.mjs";
+import { ct as detectProviders, lt as planMetroReach } from "./settings-C7O8A6ZI.mjs";
+import { M as readMetroTunnel, P as readRemoteSession } from "./project-wM_XFTvE.mjs";
+import { $n as MIN_EAS_CLI_DEVICE_VERSION, Hn as isEasAuthFailureText, Ht as readInstalledEasCliVersionAsync, Qn as remoteCommand, er as MIN_EAS_CLI_SIMULATOR_VERSION, qn as resolveEasCliBin, s as peekBudget, tr as easCliSupport } from "./budget-Cvwn54qV.mjs";
+import { F as readHostMemoryPressureAsync } from "./ios-hcBpnEGk.mjs";
+import { d as hostingMachines, o as resolveBuildMachine, r as namedBuildMachine } from "./selection-DSMbWEX2.mjs";
+import { c as call, l as connectHost, p as requireHostedAppMode } from "./hosted-client-DZAPrcro.mjs";
+import { r as readHostedNative, s as writeHostedNative } from "./ios-state-Dtw5K2aI.mjs";
+import { n as prepareHostedNative } from "./hosted-native-BdzE668-.mjs";
+import { c as peekDeviceSlots } from "./device-capacity-DK5_EwRS.mjs";
+import { ambientEnv } from "@stim-cli/core";
 import { automaticMachineEnabled, isJsonObject, machineCapacity, parseHostedChoice, parseHostedNativeOffer } from "@stim-cli/core/state";
-import { resolveTieredBuild } from "@stim-cli/cache";
-import chalk from "chalk";
 //#region src/device-host/placement.ts
 function local$1(code, reason, skipped = [], atCapacity = false) {
 	return {
@@ -85,7 +79,7 @@ function decideDevicePlacement(inputs) {
 			atCapacity: true
 		};
 	};
-	if (!offers.length) return nowhere("no-remote-mac", "no remote Macs configured; " + localReason);
+	if (!offers.length) return nowhere("no-remote-mac", "no remote machines configured; " + localReason);
 	if (localEnabled && count === null) return local$1("device-count-unknown", localReason);
 	if (!cannotTake && here.memoryPressure === "normal" && !here.budgetRefusal && here.loadPerCore < here.maxLoadPerCore) return local$1("this-mac-free", localReason);
 	const skipped = [];
@@ -100,7 +94,7 @@ function decideDevicePlacement(inputs) {
 			else if (offer.platform !== platform || !offer.choice) [code, reason] = ["no-matching-device", `no matching ${platform} device choice`];
 			else if (offer.resources.memoryPressure !== "normal") [code, reason] = ["memory", "host memory pressure unknown or elevated"];
 			else if (offer.capacity.available === 0) [code, reason] = ["no-capacity", "no hosted device capacity available"];
-			else if (!cannotTake && (offer.resources.loadPerCore === null || offer.resources.loadPerCore >= here.loadPerCore)) [code, reason] = ["load", offer.resources.loadPerCore === null ? "host load unknown while this Mac has room" : "host is not less loaded than this Mac"];
+			else if (!cannotTake && (offer.resources.loadPerCore === null || offer.resources.loadPerCore >= here.loadPerCore)) [code, reason] = ["load", offer.resources.loadPerCore === null ? "host load unknown while this machine has room" : "host is not less loaded than this machine"];
 			else admitted.push({
 				machine: probe.machine,
 				offer,
@@ -117,7 +111,7 @@ function decideDevicePlacement(inputs) {
 	if (!admitted.length) return nowhere("no-host-admits", `${localReason}; no host admits`, skipped, localEnabled && cannotTake && !noWait ? "; waiting locally if needed" : "");
 	const machines = admitted.map(({ machine, offer }) => ({
 		machine,
-		reason: `${localReason}; ${machine}${machine === buildMachine ? " is the explicit remote Mac," : ""} load ${offer.resources.loadPerCore === null ? "unknown" : offer.resources.loadPerCore.toFixed(1) + "/core"}`
+		reason: `${localReason}; ${machine}${machine === buildMachine ? " is the explicit remote machine," : ""} load ${offer.resources.loadPerCore === null ? "unknown" : offer.resources.loadPerCore.toFixed(1) + "/core"}`
 	}));
 	return {
 		kind: "host",
@@ -129,16 +123,20 @@ function decideDevicePlacement(inputs) {
 }
 //#endregion
 //#region src/device-host/auto-placement.ts
-async function probeHost(machine, platform, selectors, appMode) {
+async function probeHost(machine, platform, selectors, appMode, signal) {
 	let host;
 	const deadline = Date.now() + 3e3;
+	const cancel = () => host?.connection.close();
 	try {
-		host = await connectHost(machine, 3e3, true);
+		host = await connectHost(machine, 3e3, true, signal);
+		signal?.addEventListener("abort", cancel, { once: true });
+		signal?.throwIfAborted();
 		requireHostedAppMode(host, platform, appMode);
 		const offer = await call(host, "device-host.offer", {
 			platform,
 			...selectors
 		}, Math.max(1, deadline - Date.now()));
+		signal?.throwIfAborted();
 		const resources = isJsonObject(offer.resources) ? offer.resources : {};
 		const parsed = parseHostedNativeOffer({
 			...offer,
@@ -172,11 +170,13 @@ async function probeHost(machine, platform, selectors, appMode) {
 			} } : {}
 		};
 	} catch (error) {
+		signal?.throwIfAborted();
 		return { probe: {
 			machine,
 			failure: error instanceof Error ? error.message : String(error)
 		} };
 	} finally {
+		signal?.removeEventListener("abort", cancel);
 		host?.connection.close();
 	}
 }
@@ -219,11 +219,11 @@ function viaEas(code, reason, skipped) {
 		skipped
 	};
 }
-async function automaticDevicePlacement({ root, slot, platform, selectors, appMode, buildMachine, noWait, eas }, { machines = hostingMachines, read = readHostedNative, write = writeHostedNative, resume = prepareHostedNative, peek = () => peekDeviceSlots({
+async function automaticDevicePlacement({ root, slot, platform, selectors, appMode, buildMachine, noWait, eas, signal }, { machines = () => hostingMachines(void 0, signal), read = readHostedNative, write = writeHostedNative, resume = prepareHostedNative, peek = () => peekDeviceSlots({
 	platform,
 	project: getProject(root),
 	slot
-}), capacity = machineCapacity, memory = readHostMemoryPressure, probe = probeHost, budget = peekBudget } = {}) {
+}), capacity = machineCapacity, memory = () => readHostMemoryPressureAsync(void 0, void 0, signal), probe = probeHost, budget = (projectRoot) => peekBudget(projectRoot, {}, ambientEnv(), signal) } = {}) {
 	const recorded = read(root, platform, slot)[slot];
 	if (recorded) {
 		const target = await resume(recorded.machine, selectors, recorded, platform, true, appMode);
@@ -245,21 +245,23 @@ async function automaticDevicePlacement({ root, slot, platform, selectors, appMo
 		...local("sticky", decideDevicePlacement({ sticky: { local: true } }).reason),
 		sticky: true
 	};
-	const configured = machines();
+	const configured = await machines();
+	signal?.throwIfAborted();
 	if (configured === null) throw Object.assign(/* @__PURE__ */ new Error("remote.machines is invalid. Run stim guide settings and correct it."), { code: "STIM_HOSTING_REFUSED" });
 	const config = loadConfig$1();
 	const entries = configured.filter((machine) => automaticMachineEnabled("device", machine, config));
-	const preference = resolveBuildMachine(buildMachine, process.env.STIM_REMOTE_BUILD, config?.remote?.build);
+	const preference = resolveBuildMachine(buildMachine, ambientEnv().STIM_REMOTE_BUILD, config?.remote?.build);
 	buildMachine = namedBuildMachine(preference) ? preference : void 0;
 	const load = capacity();
 	const here = {
 		localEnabled: automaticMachineEnabled("device", "local", config),
 		loadPerCore: load.loadPerCore,
 		maxLoadPerCore: load.maxLoadPerCore,
-		memoryPressure: memory(),
+		memoryPressure: await memory(),
 		devices,
 		budgetRefusal: await budget(root)
 	};
+	signal?.throwIfAborted();
 	const inputs = (offers) => ({
 		platform,
 		here,
@@ -272,7 +274,7 @@ async function automaticDevicePlacement({ root, slot, platform, selectors, appMo
 		failure: "not probed"
 	}));
 	const early = decideDevicePlacement(inputs(notProbed));
-	const probes = early.kind === "local" && early.skipped.length === 0 ? [] : await Promise.all(entries.map((machine) => probe(machine, platform, selectors, appMode)));
+	const probes = early.kind === "local" && early.skipped.length === 0 ? [] : await Promise.all(entries.map((machine) => probe(machine, platform, selectors, appMode, signal)));
 	const offers = probes.length ? probes.map((each) => each.probe) : notProbed;
 	let decision = decideDevicePlacement(inputs(offers));
 	if ((decision.kind === "local" || decision.kind === "refused") && decision.atCapacity && eas) decision = decideDevicePlacement({
@@ -323,14 +325,18 @@ function parseSimulatorAvailability(outcome) {
 * Whether this run could use an EAS Simulator the way `--remote eas` does, without starting a session or a build.
 * Each refusal names what `--remote eas` would refuse later, so automatic placement falls through instead.
 */
-async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelMode, publicUrl, deviceTypeFlag, localOnlyFlags, env = process.env, resolveBin = resolveEasCliBin, readVersion = readInstalledEasCliVersion, onPath = (bin) => getExecutor().findExecutable(bin) !== null, readTunnel = readMetroTunnel, readSession = readRemoteSession, metroPort = () => getProject(root)?.metroPort ?? null, availability = async (bin) => {
+async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelMode, publicUrl, deviceTypeFlag, localOnlyFlags, env = process.env, resolveBin = resolveEasCliBin, readVersion = readInstalledEasCliVersionAsync, operation, onPath = (bin) => getExecutor().findExecutable(bin) !== null, readTunnel = readMetroTunnel, readSession = readRemoteSession, metroPort = () => getProject(root)?.metroPort ?? null, availability = async (bin) => {
 	try {
-		return { stdout: await getExecutor().runFileAsync(bin, [
+		return { stdout: await remoteCommand({
+			operation,
+			easBin: bin
+		}, bin, [
 			"simulator:availability",
 			"--json",
 			"--non-interactive"
 		], {
 			cwd: root,
+			...childEnvironment(env),
 			timeoutMs: AVAILABILITY_TIMEOUT_MS
 		}) };
 	} catch (error) {
@@ -347,9 +353,10 @@ async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelM
 	if (session && session.platform !== platform) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.platform ?? "another platform"}`);
 	if (session && deviceTypeFlag?.trim() && session.deviceType !== deviceTypeFlag.trim()) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.deviceType ?? "the model EAS chose"}, not ${deviceTypeFlag.trim()}`);
 	if (!onPath("agent-device")) return unusable("eas-no-agent-device", "agent-device is not on PATH");
+	throwIfCancelled(operation?.signal, "EAS availability");
 	const bin = resolveBin(root);
 	if (!bin) return unusable("eas-no-cli", "eas-cli is not installed for this project or on PATH");
-	const versionOutput = readVersion(bin.file, root);
+	const versionOutput = await readVersion(bin.file, root, operation);
 	const minimum = platform === "ios" && deviceTypeFlag?.trim() ? MIN_EAS_CLI_DEVICE_VERSION : MIN_EAS_CLI_SIMULATOR_VERSION;
 	const { supported, version } = easCliSupport(versionOutput, minimum);
 	if (!supported) return unusable("eas-cli-too-old", `eas-cli ${version ?? "(unknown version)"} is older than ${minimum}`);
@@ -370,184 +377,4 @@ async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelM
 	return parseSimulatorAvailability(await availability(bin.file));
 }
 //#endregion
-//#region src/commands/build-plan.ts
-const DISCARD = {
-	file: "",
-	written: 0,
-	dropped: 0,
-	lastError: null,
-	write: () => true,
-	close: () => ({
-		file: "",
-		written: 0,
-		dropped: 0,
-		lastError: null
-	})
-};
-async function providerHit({ root, platform, cacheKey, providerConfig }, deps) {
-	if (!providerConfig) return null;
-	let destinationDir;
-	try {
-		destinationDir = makeTemporaryDirectory(root, "stim-plan-");
-	} catch (error) {
-		deps.note(chalk.yellow(phaseLine("cache", `provider not checked: ${error?.message || error}`)));
-		return null;
-	}
-	try {
-		const found = await resolveTieredBuild({
-			local: {
-				resolve: () => null,
-				store: () => null
-			},
-			loadProvider: () => deps.loadCacheProvider({
-				projectRoot: root,
-				config: providerConfig
-			}),
-			target: {
-				projectRoot: root,
-				platform,
-				key: cacheKey
-			},
-			destinationDir,
-			warn: (_code, message) => deps.note(chalk.yellow(phaseLine("cache", message)))
-		});
-		return found ? found.providerName ?? "the cache provider" : null;
-	} finally {
-		removeTemporaryEntry(destinationDir);
-	}
-}
-async function expoRemoteHit(lookup, deps) {
-	if (!lookup.expoRemote) return null;
-	const { root, platform, isExpo, fingerprint } = lookup;
-	const loaded = await deps.loadProjectProvider(root, { isExpo });
-	if (loaded?.unavailable) {
-		deps.note(chalk.yellow(phaseLine("cache", `provider not usable: ${loaded.unavailable}`)));
-		return null;
-	}
-	if (!loaded?.provider) return null;
-	const name = loaded.name ?? "the build cache provider";
-	if (name === "eas") {
-		const auth = deps.checkEasAuth({
-			projectRoot: root,
-			owner: loaded.owner || null
-		});
-		const authNote = easAuthNote(auth);
-		if (authNote) deps.note(chalk.yellow(phaseLine("cache", authNote)));
-		if (auth?.code === "logged-out") return null;
-	}
-	const hit = await deps.resolveRemote({
-		provider: loaded.provider,
-		platform,
-		projectRoot: root,
-		fingerprintHash: fingerprint,
-		runOptions: lookup.expoRemote.runOptions,
-		logWriter: DISCARD
-	});
-	if (hit?.timedOut) deps.note(chalk.yellow(phaseLine("cache", `${name} did not answer; counted as a miss`)));
-	else if (hit?.failed) deps.note(chalk.yellow(phaseLine("cache", `${name} could not be used: ${hit.failed}`)));
-	return hit?.appPath ? name : null;
-}
-async function planCachedBuild(lookup, deps) {
-	const { root, platform, isExpo, fingerprint, sources, cacheKey, cachePolicy } = lookup;
-	let cacheHit = false;
-	let provider = null;
-	if (cachePolicy.read) {
-		if (artifactIn(entryDir(platform, cacheKey))) cacheHit = "local";
-		else {
-			provider = (cachePolicy.remote ? await providerHit(lookup, deps) : null) ?? await expoRemoteHit(lookup, deps);
-			if (provider) cacheHit = "remote";
-		}
-	}
-	let prebuild = null;
-	let refusal = null;
-	let missReason;
-	if (!cacheHit) {
-		prebuild = deps.planPrebuild(root, platform, {
-			isExpo,
-			fingerprint,
-			sources
-		});
-		if (prebuild === "refuse") refusal = staleNativeDirRefusal(platform);
-		else if (cachePolicy.read) missReason = predictBuildMiss({
-			root,
-			platform,
-			current: {
-				hash: fingerprint,
-				sources
-			},
-			prebuild: prebuild === "generate" || prebuild === "regenerate" ? prebuild : null
-		});
-	}
-	return planPayload(lookup, {
-		fingerprint,
-		cacheKey,
-		cacheHit,
-		provider,
-		cacheSkipped: !cachePolicy.read,
-		prebuild,
-		...missReason ? { missReason } : {},
-		refusal
-	});
-}
-function planPayload({ platform, slot, projectKey }, found) {
-	const { refusal, missReason, ...rest } = found;
-	const outcome = refusal ? null : found.cacheHit ? "hit" : "cold";
-	const estimate = outcome ? estimateBuild(readStats$1().record?.history?.[projectKey], platform, outcome) : {
-		expectedMs: null,
-		basis: 0
-	};
-	return {
-		platform,
-		...slot === "default" ? {} : { slot },
-		...rest,
-		outcome,
-		expectedMs: estimate.expectedMs,
-		basis: estimate.basis,
-		...missReason ? { missReason } : {},
-		...refusal ? { refusal } : {}
-	};
-}
-function cacheLine(plan) {
-	if (plan.refusal) return `the build would refuse with ${plan.refusal.code}`;
-	if (plan.cacheHit === "local") return "local cache hit";
-	if (plan.cacheHit === "remote") return `remote cache hit (${plan.provider})`;
-	return `${plan.cacheSkipped ? "cache reads are off" : "cache miss"}: compiles${plan.prebuild === "generate" || plan.prebuild === "regenerate" ? `, ${plan.prebuild}s the native dir` : ""}`;
-}
-function printPlan(plan, json) {
-	if (json) {
-		console.log(JSON.stringify(plan));
-		return;
-	}
-	const slot = plan.slot ? ` [${plan.slot}]` : "";
-	console.log(phaseLine("plan", `${plan.platform}${slot} ${shortHash(plan.fingerprint)} -> ${cacheLine(plan)}`));
-	if (plan.placement) console.log(phaseLine("placement", plan.placement));
-	if (plan.missReason) console.log(phaseLine("cache", `miss: ${plan.missReason.summary}`));
-	if (plan.refusal) {
-		console.log(phaseLine("error", plan.refusal.message));
-		console.log(phaseLine("remedy", plan.refusal.remedy));
-		return;
-	}
-	console.log(phaseLine("expect", plan.expectedMs === null ? `unknown: no ${plan.outcome} run of this project is recorded yet` : `~${formatDuration(plan.expectedMs)} (median of ${plural(plan.basis, `${plan.outcome} run`)})`));
-}
-function refusePlan({ code, message, remedy }, json, lines = []) {
-	console.error(chalk.red(phaseLine("error", message)));
-	for (const line of lines) console.error(chalk.dim(phaseLine("", line)));
-	console.error(chalk.dim(phaseLine("remedy", remedy)));
-	console.error(chalk.red(phaseLine("failed", code)));
-	if (json) console.log(JSON.stringify({
-		code,
-		message,
-		remedy
-	}));
-	process.exitCode = 1;
-}
-const PLAN_ONLY_REMEDY = "Drop the flag to plan the owned simulator or emulator build, or run the command without --plan.";
-function planFlagRefusal(flag) {
-	return {
-		code: "STIM_BAD_ARG",
-		message: `${flag} does not apply to --plan, which predicts the next local build without choosing a device.`,
-		remedy: PLAN_ONLY_REMEDY
-	};
-}
-//#endregion
-export { refusePlan as a, devicePlacementLine as c, printPlan as i, probeHost as l, planFlagRefusal as n, checkEasFallback as o, planPayload as r, automaticDevicePlacement as s, planCachedBuild as t };
+export { probeHost as i, automaticDevicePlacement as n, devicePlacementLine as r, checkEasFallback as t };

package/dist/{watchman-CPQFZLXY.mjs → eas-session-ledger-DlY_serQ.mjs}

@@ -1,11 +1,14 @@
-import { B as deviceSlotKey, W as projectDeviceSlots } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { y as workspaceAgentDeviceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { a as formatElapsed, o as formatLongDuration, r as clockTime, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { n as isInsideProject } from "./metro-DnCEjCxs.mjs";
-import { r as cdpEndpoint } from "./state-D1Icyjlu.mjs";
-import { basename, sep } from "path";
-import { ACTIVITY_RECENCY_BASES } from "@stim-cli/core/state";
+import { _ as reportSignal, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { l as workspaceAgentDeviceDir, v as withDirLock$1, y as withDirLockAsync$1 } from "./paths-DQtTgsBf.mjs";
+import { G as projectDeviceSlots, V as deviceSlotKey } from "./config-DlrsduwG.mjs";
+import { a as formatElapsed, o as formatLongDuration, r as clockTime, u as plural } from "./command-output-gwpm28fu.mjs";
+import { n as isInsideProject } from "./metro-DiXtA3Ty.mjs";
+import { r as cdpEndpoint } from "./state--smjFSTL.mjs";
+import { accessSync, constants, existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { workspaceId } from "@stim-cli/core";
+import { ACTIVITY_RECENCY_BASES, easMachineStateRoot, easMachineStateRoot as easMachineStateRoot$1, easSessionLedgerFile, easSessionLedgerLock, readEasSessionLedger, readEasSessionLedger as readEasSessionLedger$1, validEasSessionClaim } from "@stim-cli/core/state";
+import { basename as basename$1, sep as sep$1 } from "path";
 //#region src/status.ts
 const IOS_SIM_MB = 1500;
 const ANDROID_EMULATOR_MB = 2500;
@@ -127,6 +130,7 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 	}
 	return {
 		path: project.__path,
+		workspaceId: workspaceId(project.__path),
 		...slots.length ? { slots } : {},
 		live,
 		memoryMb,
@@ -292,7 +296,7 @@ function warningTexts(issues) {
 function portHolder(cwd, self, workspaces = []) {
 	if (!cwd) return "another app";
 	const owner = workspaces.filter((path) => path !== self && isInsideProject(cwd, path)).toSorted((a, b) => b.length - a.length)[0];
-	if (owner) return `Metro for workspace ${basename(owner)}`;
+	if (owner) return `Metro for workspace ${basename$1(owner)}`;
 	return `a dev server in ${cwd.split(/[\\/]/).filter(Boolean).slice(-3).join("/")}`;
 }
 function issueText(issue) {
@@ -383,7 +387,7 @@ function tightVolumes(volumes) {
 	return (volumes || []).filter((v) => v && diskIsTight(v.disk));
 }
 function contains(dir, path) {
-	return path === dir || path.startsWith(dir.endsWith(sep) ? dir : dir + sep);
+	return path === dir || path.startsWith(dir.endsWith(sep$1) ? dir : dir + sep$1);
 }
 function enclosingWorktree(worktrees, path) {
 	return worktrees.filter((w) => contains(w.path, path)).toSorted((a, b) => b.path.length - a.path.length)[0] ?? null;
@@ -501,4 +505,219 @@ function parseWatchmanClients(payload) {
 	return parsed;
 }
 //#endregion
-export { statusActivity as C, withWebFacts as E, remoteDeviceState as S, unprovisionedWorktrees as T, gitSummaryText as _, parseWatchmanPid as a, poolLine as b, activityLabel as c, capacity as d, deviceLeaseLines as f, formatSpace as g, environmentState as h, parseWatchmanClients as i, addReverseMissingIssue as l, diskLine as m, parseTriggerCount as n, runWatchman as o, deviceLeaseStates as p, parseWatchRoots as r, RECENT_LAUNCH_MS as s, parseSubscriberNames as t, applyMachineMemory as u, metroReverseTargets as v, tightVolumes as w, remoteDeviceLine as x, parseDfFree as y };
+//#region src/diagnostics/stim-installations.ts
+const VERSION_OUTPUT_LIMIT = 4096;
+function parsedVersion(version) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+	if (!match) return null;
+	const core = [
+		match[1],
+		match[2],
+		match[3]
+	];
+	if (core.some((part) => part.length > 1 && part.startsWith("0"))) return null;
+	const prereleaseParts = match[4]?.split(".");
+	if (prereleaseParts?.some((part) => !part || /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null;
+	const prerelease = prereleaseParts?.map((part) => /^\d+$/.test(part) ? Number(part) : part);
+	return {
+		core: core.map(Number),
+		prerelease: prerelease ?? null
+	};
+}
+function compareStimVersions(left, right) {
+	const a = parsedVersion(left);
+	const b = parsedVersion(right);
+	if (!a || !b) return null;
+	for (let index = 0; index < a.core.length; index += 1) {
+		const difference = (a.core[index] ?? 0) - (b.core[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	if (!a.prerelease && !b.prerelease) return 0;
+	if (!a.prerelease) return 1;
+	if (!b.prerelease) return -1;
+	for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+		const x = a.prerelease[index];
+		const y = b.prerelease[index];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		if (x === y) continue;
+		if (typeof x === "number" && typeof y === "number") return x - y;
+		if (typeof x === "number") return -1;
+		if (typeof y === "number") return 1;
+		return x < y ? -1 : 1;
+	}
+	return 0;
+}
+function parseStimVersionOutput(output) {
+	const version = output?.split("\n")[0]?.trim() ?? "";
+	return parsedVersion(version) ? version.replace(/^v/, "") : null;
+}
+function executableNames(platform) {
+	return platform === "win32" ? [
+		"stim.cmd",
+		"stim.exe",
+		"stim"
+	] : ["stim"];
+}
+function stimExecutablePaths(pathValue, { platform = process.platform, cwd = process.cwd() } = {}) {
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of pathValue.split(delimiter)) {
+		const directory = resolve(cwd, entry || ".");
+		for (const name of executableNames(platform)) {
+			const path = join(directory, name);
+			try {
+				accessSync(path, platform === "win32" ? constants.F_OK : constants.X_OK);
+				if (!statSync(path).isFile()) continue;
+				const realPath = realpathSync(path);
+				if (seen.has(realPath)) continue;
+				seen.add(realPath);
+				found.push({
+					path,
+					realPath
+				});
+			} catch {}
+		}
+	}
+	return found;
+}
+function canonicalPath(path, cwd) {
+	if (!path) return null;
+	try {
+		return realpathSync(resolve(cwd, path));
+	} catch {
+		return resolve(cwd, path);
+	}
+}
+function analyzeStimVersions(runningVersion, runningPath, installations) {
+	const candidates = [runningVersion, ...installations.map((entry) => entry.version)];
+	const versions = [...new Set(candidates)].filter((version) => version !== null && compareStimVersions(version, version) !== null).toSorted((left, right) => -(compareStimVersions(left, right) ?? 0));
+	const highestVersion = versions[0] ?? null;
+	const resolved = installations[0] ?? null;
+	return {
+		runningVersion,
+		runningPath,
+		resolved,
+		installations,
+		versions,
+		highestVersion,
+		resolvedIsOlder: Boolean(resolved?.version && highestVersion && (compareStimVersions(resolved.version, highestVersion) ?? 0) < 0)
+	};
+}
+function probeStimVersion(path, timeoutMs, cwd, env, operation) {
+	if (reportSignal(operation)) return getExecutor().runFileQuietAsync(path, ["--version"], {
+		timeoutMs,
+		cwd,
+		env: Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0))
+	}).then((output) => output === null ? null : parseStimVersionOutput(output.slice(0, VERSION_OUTPUT_LIMIT)));
+	return new Promise((resolveProbe) => {
+		let settled = false;
+		let output = "";
+		const finish = (version) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolveProbe(version);
+		};
+		let child;
+		try {
+			child = getExecutor().spawn(path, ["--version"], {
+				cwd,
+				env,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				],
+				detached: process.platform !== "win32"
+			});
+		} catch {
+			resolveProbe(null);
+			return;
+		}
+		const timer = setTimeout(() => {
+			try {
+				if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
+				else child.kill("SIGKILL");
+			} catch {}
+			finish(null);
+		}, timeoutMs);
+		child.stdout?.on("data", (chunk) => {
+			if (output.length < VERSION_OUTPUT_LIMIT) output += String(chunk).slice(0, VERSION_OUTPUT_LIMIT - output.length);
+		});
+		child.on("error", () => finish(null));
+		child.on("close", (code) => finish(code === 0 ? parseStimVersionOutput(output) : null));
+	});
+}
+async function inspectStimVersions(runningVersion, { cwd = process.cwd(), env = process.env, pathValue = env[process.platform === "win32" ? Object.keys(env).toSorted().find((key) => key.toUpperCase() === "PATH") ?? "PATH" : "PATH"] ?? "", runningPath = process.argv[1], probeTimeoutMs = 5e3, operation } = {}) {
+	const paths = stimExecutablePaths(pathValue, { cwd });
+	const versions = await Promise.all(paths.map((entry) => probeStimVersion(entry.path, probeTimeoutMs, cwd, env, operation)));
+	const installations = paths.map((entry, index) => ({
+		path: entry.path,
+		realPath: entry.realPath,
+		version: versions[index] ?? null
+	}));
+	return analyzeStimVersions(runningVersion, canonicalPath(runningPath, cwd), installations);
+}
+//#endregion
+//#region src/engine/eas-machine-root-guard-env.ts
+const EAS_TEST_GUARD_ROOT_ENV = "STIM_TEST_GUARD_REAL_EAS_ROOT";
+//#endregion
+//#region src/engine/eas-session-ledger.ts
+function assertEasMachineRootWritable(root) {
+	const guardedRoot = process.env[EAS_TEST_GUARD_ROOT_ENV];
+	if (!guardedRoot || resolve(root) !== resolve(guardedRoot)) return;
+	throw new Error(`Refusing to write the real EAS machine root ${root} from a test process. Pass a temporary ledgerRoot, machineRoot, or easLedgerRoot, or point HOME (and USERPROFILE on Windows) at a temporary directory.`);
+}
+function writeLedger(root, ledger) {
+	mkdirSync(root, { recursive: true });
+	const file = easSessionLedgerFile(root);
+	const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`);
+	try {
+		renameSync(tmp, file);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function recordEasSessionClaim(claim, root = easMachineStateRoot()) {
+	assertEasMachineRootWritable(root);
+	const normalized = validEasSessionClaim(claim.sessionId, claim);
+	if (!normalized) throw new Error(`Invalid EAS session claim for ${claim.sessionId}.`);
+	withDirLock$1(easSessionLedgerLock(root), () => {
+		const current = readEasSessionLedger(root);
+		if (!current.safe) throw new Error(current.notice ?? "EAS ownership ledger is unreadable.");
+		current.claims.set(normalized.sessionId, normalized);
+		writeLedger(root, {
+			version: 1,
+			claims: Object.fromEntries(current.claims)
+		});
+	}, { ensureParent: () => mkdirSync(dirname(easSessionLedgerLock(root)), { recursive: true }) });
+}
+function removeEasSessionClaim(sessionId, root = easMachineStateRoot(), when = () => true) {
+	const file = easSessionLedgerFile(root);
+	if (!existsSync(file)) return false;
+	assertEasMachineRootWritable(root);
+	return withDirLock$1(easSessionLedgerLock(root), () => {
+		const current = readEasSessionLedger(root);
+		if (!current.safe) return false;
+		const claim = current.claims.get(sessionId);
+		if (!claim || !when(claim)) return false;
+		current.claims.delete(sessionId);
+		writeLedger(root, {
+			version: 1,
+			claims: Object.fromEntries(current.claims)
+		});
+		return true;
+	});
+}
+/** Removes a matching EAS session claim after asynchronously acquiring the ownership ledger lock. */
+async function removeEasSessionClaimAsync(sessionId, root = easMachineStateRoot(), when = () => true, signal) {
+	signal?.throwIfAborted();
+	if (!existsSync(easSessionLedgerFile(root))) return false;
+	assertEasMachineRootWritable(root);
+	return withDirLockAsync$1(easSessionLedgerLock(root), () => removeEasSessionClaim(sessionId, root, when), { signal });
+}
+//#endregion
+export { remoteDeviceState as A, environmentState as C, parseDfFree as D, metroReverseTargets as E, tightVolumes as M, unprovisionedWorktrees as N, poolLine as O, withWebFacts as P, diskLine as S, gitSummaryText as T, addReverseMissingIssue as _, removeEasSessionClaim as a, deviceLeaseLines as b, inspectStimVersions as c, parseWatchRoots as d, parseWatchmanClients as f, activityLabel as g, RECENT_LAUNCH_MS as h, recordEasSessionClaim as i, statusActivity as j, remoteDeviceLine as k, parseSubscriberNames as l, runWatchman as m, easMachineStateRoot$1 as n, removeEasSessionClaimAsync as o, parseWatchmanPid as p, readEasSessionLedger$1 as r, compareStimVersions as s, assertEasMachineRootWritable as t, parseTriggerCount as u, applyMachineMemory as v, formatSpace as w, deviceLeaseStates as x, capacity as y };