stim 1.17.1 → 1.18.0

package/dist/build-facts-DcLv2HSd.d.mts

@@ -0,0 +1,111 @@
+//#region src/engine/build-facts.d.ts
+type CacheHitLevel = "local" | "remote" | false;
+type LaunchStatus = boolean | "unverified" | "bundling";
+interface LogsInfo {
+  dir?: string;
+}
+interface CompilationCacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  cacheableTasks: number | null;
+  hitRatePercent: number | null;
+  swiftTargetsWithoutExplicitModules?: number;
+}
+interface CcacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  misses: number | null;
+  hitRatePercent: number | null;
+}
+interface DevServerStart {
+  started: true;
+  reason: "not running" | "stopped (idle)";
+}
+interface RunLeaseFacts {
+  kind: string;
+  expiresAt: string;
+}
+interface IosFacts {
+  devicePlacement?: import("@stim-cli/core/state").DevicePlacement;
+  host?: import("@stim-cli/core/state").HostedIosStatus;
+  slot?: string;
+  platform: string;
+  udid: string;
+  deviceName: string | null;
+  deviceType: string | null;
+  runtime: string | null;
+  fingerprint?: string | null;
+  configuration: string | null;
+  scheme?: string;
+  cacheKey?: string | null;
+  cacheHit: CacheHitLevel;
+  cacheSkipped: boolean;
+  buildMachine?: string;
+  builtOn?: string;
+  /** The remote Mac that compiled the app when the build was offloaded; absent otherwise. */
+  offloadedTo?: string;
+  /** Why the app was built here after the run considered offloading it; absent otherwise. */
+  offloadFallback?: string;
+  compilationCache: CompilationCacheActivity;
+  waitedForBuild: {
+    pid: number | null;
+    ms: number;
+  } | null;
+  appPath?: string | null;
+  bundleId?: string | null;
+  installSkipped: boolean;
+  launched: LaunchStatus;
+  metroPort?: number | null;
+  logs: LogsInfo;
+  agentDevice?: {
+    stateDir: string;
+  };
+  durationMs?: number;
+  webPreviewUrl?: string | null;
+  lease?: RunLeaseFacts | null;
+  devServer?: DevServerStart;
+}
+interface AndroidFacts {
+  devicePlacement?: import("@stim-cli/core/state").DevicePlacement;
+  host?: import("@stim-cli/core/state").HostedAndroidStatus;
+  slot?: string;
+  platform: string;
+  serial: string | null;
+  avdName: string | null;
+  deviceName: string | null;
+  systemImage: string | null;
+  deviceProfile: string | null;
+  fingerprint: string | null;
+  cacheKey: string | null;
+  variant: string | null;
+  metroPort: number | null;
+  cacheHit: CacheHitLevel;
+  cacheSkipped: boolean;
+  buildMachine?: string;
+  builtOn?: string;
+  /** The remote Mac that compiled the APK when the build was offloaded; absent otherwise. */
+  offloadedTo?: string;
+  /** Why the APK was built here after the run considered offloading it; absent otherwise. */
+  offloadFallback?: string;
+  waitedForBuild: {
+    pid: number | null;
+    ms: number;
+  } | null;
+  appPath: string | null;
+  bundleId: string | null;
+  installSkipped: boolean;
+  launched: LaunchStatus;
+  ccache: CcacheActivity;
+  debugHttpHost: string | null;
+  debugHttpHostNote: string | null;
+  devClientUrl: string | null;
+  logs: string | null;
+  agentDevice?: {
+    stateDir: string;
+  };
+  durationMs: number | null;
+  lease?: RunLeaseFacts | null;
+  devServer?: DevServerStart;
+}
+//#endregion
+export { IosFacts as i, CcacheActivity as n, CompilationCacheActivity as r, AndroidFacts as t };

package/dist/{cache-manifest-DnUHBJaU.mjs → cache-manifest-BI7ozfmH.mjs}

@@ -1,8 +1,8 @@
-import { d as getConfigDir } from "./config-D0DbpZtM.mjs";
-import { existsSync } from "fs";
-import { homedir } from "os";
+import { d as getConfigDir } from "./config-CgYMahz7.mjs";
 import { isAbsolute, join, resolve } from "path";
+import { existsSync } from "fs";
 import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";
+import { homedir } from "os";
 //#region src/cache/cache-manifest.ts
 function manifestPath() {
 	return join(getConfigDir(), "caches.json");

package/dist/cache-manifest.mjs

@@ -1,2 +1,2 @@
-import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-DnUHBJaU.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-BI7ozfmH.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/{chrome-BrcVWQyD.mjs → chrome-DJnmnS5q.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";

package/dist/cli-DNJMwADx.mjs

@@ -0,0 +1,68 @@
+import { n as debugLog } from "./exec-DWhCZDGm.mjs";
+import { y as refuseRelativeStimPaths } from "./config-CgYMahz7.mjs";
+import { readFileSync } from "node:fs";
+import { runId } from "@stim-cli/core/state";
+import { Command } from "commander";
+//#region bin/cli.ts
+const commands = /* @__PURE__ */ new Map([
+	["doctor", () => import("./doctor-B9ckYUoU.mjs")],
+	["worktree", () => import("./worktree-BJfnU6r5.mjs")],
+	["start", () => import("./start-NTc1Ifqs.mjs")],
+	["ports", () => import("./ports-BLTtfBq-.mjs")],
+	["stop", () => import("./stop-DIJtD2GL.mjs")],
+	["ios", () => import("./ios-DNpdygiv.mjs")],
+	["android", () => import("./android-BKA16DTf.mjs")],
+	["web", () => import("./web-B6_bFDn7.mjs")],
+	["macos", () => import("./macos-Ck7OBMNY.mjs")],
+	["reload", () => import("./reload-DvyWzVjJ.mjs")],
+	["device", () => import("./device-D7oCHGWi.mjs")],
+	["logs", () => import("./logs-1Ylc1Ri6.mjs")],
+	["settings", () => import("./settings-Byp2AQ_E.mjs")],
+	["status", () => import("./status-DCjZeE-K.mjs")],
+	["stats", () => import("./stats-DY6ekz8F.mjs")],
+	["gc", () => import("./gc-Dh6mXOKC.mjs")],
+	["guide", () => import("./guide-tm6igAaa.mjs")]
+]);
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+const program = new Command();
+program.name("stim").description("Isolated React Native dev environments per project/worktree").version(pkg.version);
+try {
+	refuseRelativeStimPaths();
+	process.env.STIM_RUN_ID = runId();
+	const first = process.argv[2];
+	const loadCommand = commands.get((first === "help" ? process.argv[3] : first) ?? "");
+	if (loadCommand) (await loadCommand()).default(program, pkg.version);
+	else if (first !== "--version" && first !== "-V") {
+		const modules = await Promise.all([...commands.values()].map((load) => load()));
+		for (const module of modules) module.default(program, pkg.version);
+	}
+	program.hook("preAction", async (_command, action) => {
+		if (debugLog.enabled()) {
+			const path = [];
+			for (let each = action; each?.parent; each = each.parent) path.unshift(each.name());
+			const started = Date.now();
+			debugLog.log("run_start", {
+				version: pkg.version,
+				command: path,
+				flags: process.argv.slice(2).filter((arg) => arg.startsWith("-")).map((arg) => arg.split("=")[0])
+			});
+			process.on("exit", (code) => debugLog.log("run_end", {
+				exit: code,
+				ms: Date.now() - started
+			}));
+		}
+		try {
+			const { triggerMaintenance } = await import("./trigger-DWAq9hkw.mjs");
+			triggerMaintenance(action.name());
+		} catch {}
+	});
+	await program.parseAsync();
+} catch (err) {
+	const code = err?.code;
+	const message = err instanceof Error ? err.message : String(err);
+	if (typeof code === "string" && code.startsWith("STIM_")) console.error(`${code}: ${message}`);
+	else console.error(`Unexpected error: ${message.replace(/\.$/, "")}. Report it at ${pkg.bugs.url}`);
+	process.exit(1);
+}
+//#endregion
+export {};

package/dist/cli.mjs

@@ -4,6 +4,6 @@ const encode = (version) => version.split(".", 3).reduce((sum, part) => sum * 1e
 if (encode(process.versions.node) < encode("22.12.0")) {
 	process.stderr.write(`STIM_NODE_UNSUPPORTED: Stim needs Node 22.12.0 or later; this is Node ${process.versions.node} at ${process.execPath}. To run Stim where a project pins an older Node, see https://stim.appandflow.com/docs/requirements#older-node-pins\n`);
 	process.exitCode = 1;
-} else import("./cli-BLQqDGlX.mjs");
+} else import("./cli-DNJMwADx.mjs");
 //#endregion
 export {};

package/dist/{client-CxNotugx.mjs → client-DzhapoMB.mjs}

@@ -1,14 +1,14 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { _ as loadConfig$1, d as getConfigDir } from "./config-D0DbpZtM.mjs";
-import { w as withDirLock } from "./workspace-state-DqcCbpE7.mjs";
-import { T as CCACHE_UNAVAILABLE, a as toolchainMismatches, l as COMPILATION_CACHE_UNAVAILABLE, s as manifestDigest } from "./toolchain-CdrxgUeA.mjs";
-import { createHash } from "node:crypto";
+import { n as debugLog, t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { _ as loadConfig$1, d as getConfigDir } from "./config-CgYMahz7.mjs";
+import { w as withDirLock } from "./workspace-state-C59dqG-Z.mjs";
+import { a as toolchainMismatches, d as readRubyVersion, h as COMPILATION_CACHE_UNAVAILABLE, j as CCACHE_UNAVAILABLE, s as manifestDigest } from "./toolchain-Bnyd_K3A.mjs";
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync, writeSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
+import { OFFLOAD_MODES, acceptsShape, buildMachinesFile, buildMachinesLock, deviceHostMachinesClaims, deviceHostMachinesFile, deviceHostMachinesLock, endpoint, findPeer as findPeer$1, isJsonObject, parseMachine, parseMachine as parseMachine$1, pinnedEndpoint, readBuildMachines, readDeviceHostMachines, runId, saturation, settingDefinition } from "@stim-cli/core/state";
+import { hostname } from "node:os";
 import { InvalidArgumentError } from "commander";
-import { OFFLOAD_MODES, acceptsShape, buildMachinesFile, buildMachinesLock, deviceHostMachinesClaims, deviceHostMachinesFile, deviceHostMachinesLock, endpoint, findPeer as findPeer$1, isJsonObject, parseMachine, parseMachine as parseMachine$1, pinnedEndpoint, readBuildMachines, readDeviceHostMachines, saturation, settingDefinition } from "@stim-cli/core/state";
 import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
-import { hostname } from "node:os";
+import { createHash } from "node:crypto";
 import { WebSocket } from "ws";
 //#region src/offload/access-ticket.ts
 function readAccessTicket() {
@@ -30,6 +30,28 @@ function readHostPermissions(value) {
 //#region src/offload/tailnet.ts
 const MAC_APP_TAILSCALE = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
 const HELLO_TIMEOUT_MS = 1e4;
+function isLapsed(credential) {
+	return credential.state === "pending" && !!credential.expiresAt && Date.parse(credential.expiresAt) <= Date.now();
+}
+function markApproved(credential) {
+	const { expiresAt: _expiresAt, ...rest } = credential;
+	return {
+		...rest,
+		state: "approved"
+	};
+}
+function pendingReport(credential) {
+	return {
+		state: "pending",
+		...credential.expiresAt ? { expiresAt: credential.expiresAt } : {}
+	};
+}
+function lapsedLine(machine, credential) {
+	return `${machine} did not approve this Mac before the request lapsed at ${credential.expiresAt}.`;
+}
+function requestedLine(credential) {
+	return `Requested at ${credential.requestedAt}${credential.expiresAt ? `; the request lapses at ${credential.expiresAt}` : ""}.`;
+}
 function tailscaleStatus() {
 	for (const binary of ["tailscale", MAC_APP_TAILSCALE]) {
 		const output = getExecutor().runFileQuiet(binary, ["status", "--json"], { timeoutMs: 5e3 });
@@ -161,6 +183,7 @@ async function request(machine, peer, port, deviceName, io) {
 		deviceToken: reply.result.deviceToken,
 		state: "pending",
 		requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		expiresAt: reply.result.approval.expiresAt,
 		...ticket ? { ticketHash: ticket.ticketHash } : {}
 	};
 	return {
@@ -169,7 +192,8 @@ async function request(machine, peer, port, deviceName, io) {
 			dnsName: peer.dnsName,
 			state: "pending",
 			deviceId: credential.deviceId,
-			requestedAt: credential.requestedAt
+			requestedAt: credential.requestedAt,
+			expiresAt: credential.expiresAt
 		},
 		finding: note$1(`Asked ${machine} for hosting access`, `The request lapses at ${reply.result.approval.expiresAt}.`, approval$1(machine, credential.deviceId)),
 		credential
@@ -300,10 +324,7 @@ async function inspectDeviceHostMachines({ fix }, io = realIo, entries = configu
 				const reply = await io.hello(endpoint(peer, parsed.port), { deviceToken: credential.deviceToken });
 				if ("result" in reply && reply.result?.device?.id === credential.deviceId && Array.isArray(reply.result.capabilities) && reply.result.capabilities.includes("device-host")) {
 					if (credential.state !== "approved") {
-						credentials = credentials.map((each) => each.machine === machine ? {
-							...each,
-							state: "approved"
-						} : each);
+						credentials = credentials.map((each) => each.machine === machine ? markApproved(each) : each);
 						store(credentials);
 					}
 					const host = readHostPermissions(reply.result.host);
@@ -326,17 +347,18 @@ async function inspectDeviceHostMachines({ fix }, io = realIo, entries = configu
 				if (pending && !ask) {
 					inspected.machines.push({
 						...known,
-						state: "pending"
+						...pendingReport(credential)
 					});
-					inspected.findings.push(note$1(`Remote Mac ${machine} has not approved this Mac for device hosting yet`, `Requested at ${credential.requestedAt}.`, approval$1(machine, credential.deviceId)));
+					inspected.findings.push(note$1(`Remote Mac ${machine} has not approved this Mac for device hosting yet`, requestedLine(credential), approval$1(machine, credential.deviceId)));
 					continue;
 				}
 				if (!ask) {
+					const lapsed = revoked && isLapsed(credential);
 					inspected.machines.push({
 						...known,
-						state: revoked ? "revoked" : "unreachable"
+						state: lapsed ? "lapsed" : revoked ? "revoked" : "unreachable"
 					});
-					inspected.findings.push(note$1(`Remote Mac ${machine} ${revoked ? "no longer accepts this Mac for device hosting" : "did not confirm hosting access"}`, "The saved token and pinned node are preserved.", revoked ? "Run `stim doctor --fix` to ask again." : `Check stim-server and its tailnet serve route on ${machine}, then run doctor again.`));
+					inspected.findings.push(note$1(lapsed ? `Hosting request to ${machine} lapsed` : `Remote Mac ${machine} ${revoked ? "no longer accepts this Mac for device hosting" : "did not confirm hosting access"}`, lapsed ? `${lapsedLine(machine, credential)} The saved token and pinned node are preserved.` : "The saved token and pinned node are preserved.", revoked ? "Run `stim doctor --fix` to ask again." : `Check stim-server and its tailnet serve route on ${machine}, then run doctor again.`));
 					continue;
 				}
 			}
@@ -471,6 +493,7 @@ async function requestAccess(entry, peer, port, deviceName, io) {
 		deviceToken: reply.result.deviceToken,
 		state: "pending",
 		requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		expiresAt: reply.result.approval.expiresAt,
 		...ticket ? { ticketHash: ticket.ticketHash } : {}
 	};
 	updateCredentials((credentials) => [...credentials.filter((each) => each.machine !== entry), credential]);
@@ -480,7 +503,8 @@ async function requestAccess(entry, peer, port, deviceName, io) {
 			state: "pending",
 			dnsName: peer.dnsName,
 			deviceId: credential.deviceId,
-			requestedAt: credential.requestedAt
+			requestedAt: credential.requestedAt,
+			expiresAt: credential.expiresAt
 		},
 		finding: note(`Asked ${entry} for build access`, `The request lapses at ${reply.result.approval.expiresAt}.`, approval(entry, credential.deviceId))
 	};
@@ -538,10 +562,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 	if ("result" in reply && reply.result.capabilities.includes("build")) {
 		const permissions = readHostPermissions(reply.result.host);
 		const host = permissions ? { host: permissions } : {};
-		if (credential.state !== "approved") updateCredentials((credentials) => credentials.map((each) => each.machine === entry ? {
-			...each,
-			state: "approved"
-		} : each));
+		if (credential.state !== "approved") updateCredentials((credentials) => credentials.map((each) => each.machine === entry ? markApproved(each) : each));
 		if (!check) return {
 			report: {
 				...paired,
@@ -574,19 +595,26 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 		return {
 			report: {
 				...paired,
-				state: "pending"
+				...pendingReport(credential)
 			},
-			finding: note(`Remote Mac ${entry} has not approved this Mac for builds yet`, `Requested at ${credential.requestedAt}.`, approval(entry, credential.deviceId))
+			finding: note(`Remote Mac ${entry} has not approved this Mac for builds yet`, requestedLine(credential), approval(entry, credential.deviceId))
 		};
 	}
 	if ("error" in reply && reply.error.code === "unauthorized") {
 		if (fix) return requestAccess(entry, peer, parsed.port, deviceName, io);
+		if (isLapsed(credential)) return {
+			report: {
+				...paired,
+				state: "lapsed"
+			},
+			finding: note(`Build request to ${entry} lapsed`, lapsedLine(entry, credential), "Run `stim doctor --fix` to ask again.")
+		};
 		return {
 			report: {
 				...paired,
 				state: "revoked"
 			},
-			finding: note(`Remote Mac ${entry} no longer accepts this Mac for builds`, `${reply.error.message} It was revoked, or the request lapsed before approval.`, "Run `stim doctor --fix` to ask again.")
+			finding: note(`Remote Mac ${entry} no longer accepts this Mac for builds`, `${reply.error.message} It was revoked or denied.`, "Run `stim doctor --fix` to ask again.")
 		};
 	}
 	const reason = "failed" in reply ? reply.failed : "error" in reply ? reply.error.message : "unexpected reply";
@@ -675,8 +703,26 @@ function requireConfiguredMachine(selected, machines) {
 	if (!match) throw new OffloadRefusal(selected, `not listed in remote.machines (configured: ${entries.join(", ") || "none"})`);
 	return match;
 }
+const settingSource = (flag, env, setting) => flag !== void 0 ? "flag" : env?.trim() ? "env" : setting !== void 0 ? "setting" : "default";
+let buildMachineFlag;
+/** The settings that decide where a build runs, with the layer each value came from, for this run's `--remote-build`. */
+function buildPlacementSettings(selected) {
+	const flag = buildMachineFlag;
+	const remote = loadConfig$1()?.remote;
+	const rawMode = process.env.STIM_REMOTE_BUILD_MODE || remote?.buildMode;
+	return [{
+		key: "remote.build",
+		value: selected,
+		from: settingSource(flag, process.env.STIM_REMOTE_BUILD, remote?.build)
+	}, {
+		key: "remote.buildMode",
+		value: selected === "local" ? "off" : OFFLOAD_MODES.includes(rawMode) ? rawMode : "auto",
+		from: settingSource(void 0, process.env.STIM_REMOTE_BUILD_MODE, remote?.buildMode)
+	}];
+}
 function resolveBuildPlacement(flag) {
 	const remote = loadConfig$1()?.remote;
+	buildMachineFlag = flag;
 	let selected = "auto";
 	try {
 		selected = resolveBuildMachine(flag, process.env.STIM_REMOTE_BUILD, remote?.build);
@@ -695,6 +741,23 @@ function resolveBuildPlacement(flag) {
 	}
 }
 //#endregion
+//#region src/remote-log.ts
+let sink = null;
+/** Where this run's failed requests to another Mac are written: its workspace log, so `stim logs` shows them. */
+function setRemoteLogSink(next) {
+	sink = next;
+}
+function reportRemoteFailure(event, fields) {
+	try {
+		sink?.({
+			src: "build",
+			level: "warn",
+			event,
+			...fields
+		});
+	} catch {}
+}
+//#endregion
 //#region src/offload/client.ts
 const CONNECT_TIMEOUT_MS = 1e4;
 const OFFER_TIMEOUT_MS = 2e4;
@@ -756,35 +819,43 @@ function offloadPlacement({ mode, machines, here, unsupported, selected = "auto"
 		if (machines === 0) throw new OffloadRefusal(selected, "no remote Mac is paired");
 		return {
 			offload: true,
+			code: "named",
 			reason: `selected with --remote-build ${selected}`
 		};
 	}
 	if (selected === "local") return {
 		offload: false,
+		code: "local-selected",
 		reason: "--remote-build local"
 	};
 	if (mode === "off") return {
 		offload: false,
+		code: "mode-off",
 		reason: "remote.buildMode is off"
 	};
 	if (machines === 0) return {
 		offload: false,
+		code: "no-remote-mac",
 		reason: "no remote Mac is paired"
 	};
 	if (unsupported) return {
 		offload: false,
+		code: "unsupported",
 		reason: unsupported
 	};
 	if (mode === "force") return {
 		offload: true,
+		code: "forced",
 		reason: "remote.buildMode is force"
 	};
 	const busy = saturation(here);
 	return busy ? {
 		offload: true,
+		code: "this-mac-busy",
 		reason: `this Mac is busy: ${busy} (${capacityText(here)})`
 	} : {
 		offload: false,
+		code: "this-mac-free",
 		reason: `${capacityText(here)} here`
 	};
 }
@@ -823,25 +894,26 @@ function offerProblems(offer, target) {
 function pickOffer({ mode, here, offers, target, selected = "auto" }) {
 	const slotsFull = here.maxBuilds > 0 && here.builds >= here.maxBuilds;
 	const reasons = [];
+	const candidates = [];
+	const skip = (machine, code, msg, detail) => {
+		reasons.push(`${machine}: ${msg}`);
+		candidates.push({
+			machine,
+			code,
+			msg,
+			...detail ? { detail } : {}
+		});
+	};
 	const ranked = [];
 	offers.forEach(({ machine, offer, failure }, index) => {
 		if (namedBuildMachine(selected) && machine !== selected) return;
-		if (!offer) return void reasons.push(`${machine}: ${failure ?? "no offer"}`);
+		if (!offer) return skip(machine, "unreachable", failure ?? "no offer");
 		const problems = offerProblems(offer, target);
-		if (problems.length) {
-			reasons.push(`${machine}: ${problems.map((problem) => problem.reason).join("; ")}`);
-			return;
-		}
+		if (problems.length) return skip(machine, problemCode(problems[0]), problems.map((problem) => problem.reason).join("; "), problems.map((problem) => problem.code));
 		const load = offer.capacity.loadPerCore;
 		if (selected === "auto" && mode === "auto" && !slotsFull) {
-			if (typeof load !== "number") {
-				reasons.push(`${machine}: capacity unknown (older stim-server) while this Mac has a free slot`);
-				return;
-			}
-			if (load >= here.loadPerCore) {
-				reasons.push(`${machine}: no less loaded (load ${load}/core there, ${here.loadPerCore}/core here)`);
-				return;
-			}
+			if (typeof load !== "number") return skip(machine, "load", "capacity unknown (older stim-server) while this Mac has a free slot");
+			if (load >= here.loadPerCore) return skip(machine, "load", `no less loaded (load ${load}/core there, ${here.loadPerCore}/core here)`);
 		}
 		const score = Number(offer.warm.checkout) + Number(offer.warm.dependencies) + Number(offer.warm.build);
 		ranked.push({
@@ -849,13 +921,22 @@ function pickOffer({ mode, here, offers, target, selected = "auto" }) {
 			score,
 			load: typeof load === "number" ? load : Number.POSITIVE_INFINITY
 		});
+		candidates.push({
+			machine,
+			code: "accepted",
+			msg: typeof load === "number" ? `can take the build (load ${load}/core there)` : "can take the build"
+		});
 	});
 	ranked.sort((a, b) => b.score - a.score || a.load - b.load);
 	return {
 		order: ranked.map((each) => each.index),
-		reasons
+		reasons,
+		candidates
 	};
 }
+function problemCode({ code }) {
+	return code === "disk" || code === "busy" || code === "unreachable" ? code : code === "runtime" ? "no-matching-device" : "version-mismatch";
+}
 const openSockets = /* @__PURE__ */ new Set();
 let closingOnExit = false;
 /**
@@ -938,7 +1019,32 @@ var BuildConnection = class BuildConnection {
 		socket.on("error", () => {});
 	}
 	/** Resolves why it could not connect; `refused` when the machine answered and turned this Mac away. */
-	static open(target, token, timeoutMs, capability = "build") {
+	static async open(target, token, timeoutMs, capability = "build") {
+		const started = performance.now();
+		const result = await BuildConnection.connect(target, token, timeoutMs, capability);
+		const ms = Math.round(performance.now() - started);
+		debugLog.log("remote_connect", {
+			host: target.host,
+			capability,
+			ms,
+			timeoutMs,
+			...result instanceof BuildConnection ? { ok: true } : {
+				ok: false,
+				failure: result.failure,
+				code: result.code
+			}
+		});
+		if (!(result instanceof BuildConnection)) reportRemoteFailure("remote_connect_failed", {
+			host: target.host,
+			capability,
+			ms,
+			timeoutMs,
+			msg: result.failure,
+			code: result.code
+		});
+		return result;
+	}
+	static connect(target, token, timeoutMs, capability) {
 		return new Promise((resolve) => {
 			const options = {
 				handshakeTimeout: timeoutMs,
@@ -968,7 +1074,8 @@ var BuildConnection = class BuildConnection {
 						protocol: 1,
 						client: {
 							name: "stim",
-							version: "1"
+							version: "1",
+							runId: runId()
 						},
 						auth: { deviceToken: token }
 					}
@@ -1000,17 +1107,36 @@ var BuildConnection = class BuildConnection {
 			message: this.closed
 		} });
 		const id = this.nextId++;
+		const started = performance.now();
+		const done = (reply) => {
+			const ms = Math.round(performance.now() - started);
+			debugLog.log("remote_request", {
+				method,
+				ms,
+				..."error" in reply ? {
+					ok: false,
+					code: reply.error.code
+				} : { ok: true }
+			});
+			if ("error" in reply) reportRemoteFailure("remote_request_failed", {
+				method,
+				ms,
+				code: reply.error.code,
+				msg: reply.error.message
+			});
+			return reply;
+		};
 		return new Promise((resolve) => {
 			const timer = setTimeout(() => {
 				this.pending.delete(id);
-				resolve({ error: {
+				resolve(done({ error: {
 					code: "timeout",
 					message: `${method} got no reply in ${timeoutMs / 1e3} s`
-				} });
+				} }));
 			}, timeoutMs);
 			this.pending.set(id, (reply) => {
 				clearTimeout(timer);
-				resolve(reply);
+				resolve(done(reply));
 			});
 			this.socket.send(JSON.stringify({
 				id,
@@ -1161,7 +1287,8 @@ async function probeMachine(credential, identity, { connectMs = CONNECT_TIMEOUT_
 	};
 	const reply = await connection.request("build.offer", {
 		repo: identity.repo,
-		...identity.lockfile ? { lockfile: identity.lockfile } : {}
+		...identity.lockfile ? { lockfile: identity.lockfile } : {},
+		...identity.rubyVersion ? { rubyVersion: identity.rubyVersion } : {}
 	}, offerMs);
 	const failure = replyError(reply);
 	if (failure || !("result" in reply)) {
@@ -1181,7 +1308,7 @@ async function probeMachine(credential, identity, { connectMs = CONNECT_TIMEOUT_
 * Asks every paired machine for an offer in parallel and keeps the connection to the one `pickOffer` chooses, or
 * returns why none takes the build. A named selection probes only its credential and skips auto load gating.
 */
-async function chooseBuildMachine({ projectRoot, target, mode, here, note, machines = pairedMachines(), selected = "auto" }) {
+async function chooseBuildMachine({ projectRoot, target, mode, here, note, machines = pairedMachines(), selected = "auto", onCandidates }) {
 	const started = Date.now();
 	let identity;
 	try {
@@ -1190,8 +1317,12 @@ async function chooseBuildMachine({ projectRoot, target, mode, here, note, machi
 		return `this app is not in a git checkout (${error.message.split("\n")[0]})`;
 	}
 	if (namedBuildMachine(selected)) machines = machines.filter((each) => each.machine === selected).slice(0, 1);
-	const asked = await Promise.all(machines.map((credential) => probeMachine(credential, identity)));
-	const { order, reasons } = pickOffer({
+	const rubyVersion = readRubyVersion(projectRoot) ?? void 0;
+	const asked = await Promise.all(machines.map((credential) => probeMachine(credential, {
+		...identity,
+		rubyVersion
+	})));
+	const { order, reasons, candidates } = pickOffer({
 		selected,
 		mode,
 		here,
@@ -1205,6 +1336,7 @@ async function chooseBuildMachine({ projectRoot, target, mode, here, note, machi
 	asked.forEach((each, at) => {
 		if (!order.includes(at) && "connection" in each) each.connection.close();
 	});
+	onCandidates?.(candidates);
 	if (order.length === 0) return reasons.length ? reasons.join("; ") : "no remote Mac is paired";
 	for (const reason of reasons) note(reason);
 	const [first, ...rest] = order.map((at) => {
@@ -1606,7 +1738,10 @@ function offloadCheck(projectRoot, targets) {
 				reason: `this app is not in a git checkout (${identity})`
 			}]
 		};
-		const probe = await probeMachine(credential, identity, {
+		const probe = await probeMachine(credential, {
+			...identity,
+			rubyVersion: readRubyVersion(projectRoot) ?? void 0
+		}, {
 			connectMs: DOCTOR_CONNECT_MS,
 			offerMs: DOCTOR_OFFER_MS
 		});
@@ -1634,4 +1769,4 @@ function offloadCheck(projectRoot, targets) {
 	};
 }
 //#endregion
-export { realIo as S, configuredMachines as _, offloadBuild as a, parseMachine$1 as b, placementLoad as c, OffloadRefusal as d, namedBuildMachine as f, inspectBuildMachines as g, resolveBuildPlacement as h, closeOffload as i, remotePhaseText as l, resolveBuildMachine as m, buildPlacementCandidates as n, offloadCheck as o, parseBuildMachineOption as p, chooseBuildMachine as r, offloadPlacement as s, BuildConnection as t, simulatorRuntime as u, hostingMachines as v, pinnedEndpoint$1 as x, inspectDeviceHostMachines as y };
+export { pinnedEndpoint$1 as C, parseMachine$1 as S, resolveBuildPlacement as _, offloadBuild as a, hostingMachines as b, placementLoad as c, setRemoteLogSink as d, OffloadRefusal as f, resolveBuildMachine as g, parseBuildMachineOption as h, closeOffload as i, remotePhaseText as l, namedBuildMachine as m, buildPlacementCandidates as n, offloadCheck as o, buildPlacementSettings as p, chooseBuildMachine as r, offloadPlacement as s, BuildConnection as t, simulatorRuntime as u, inspectBuildMachines as v, realIo as w, inspectDeviceHostMachines as x, configuredMachines as y };