stim 1.17.2 → 1.19.0

package/dist/{client-SvBdgObD.mjs → client-CuUo8Nvg.mjs}

@@ -1,14 +1,19 @@
-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-DNyR3NPq.mjs";
-import { createHash } from "node:crypto";
+import { n as debugLog, t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { a as formatElapsed } from "./command-output-Bt8ygHE7.mjs";
+import { _ as loadConfig$1, d as getConfigDir } from "./config-DC5jEtd1.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as workspaceDir, w as withDirLock } from "./workspace-state-CR9X86xJ.mjs";
+import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-Kqiifsk2.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-B4iWH4E-.mjs";
+import { r as CCACHE_UNAVAILABLE, t as manifestDigest } from "./manifest-CX0d1IkZ.mjs";
+import { a as toolchainMismatches, m as COMPILATION_CACHE_UNAVAILABLE, u as readRubyVersion } from "./toolchain-C3xSoyUl.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, automaticMachineEnabled, buildMachinesFile, buildMachinesLock, deviceHostMachinesClaims, deviceHostMachinesFile, deviceHostMachinesLock, endpoint, findPeer as findPeer$1, isJsonObject, parseMachine, parseMachine as parseMachine$1, pinnedEndpoint, readBuildMachines, readDeviceHostMachines, requireAutomaticMachine, 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 { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { WebSocket } from "ws";
 //#region src/offload/access-ticket.ts
 function readAccessTicket() {
@@ -689,6 +694,9 @@ function parseBuildMachineOption(value) {
 		throw new InvalidArgumentError(error.message);
 	}
 }
+function requireLocalBuild(selected) {
+	if (selected === "auto" && !automaticMachineEnabled("build", "local")) throw new OffloadRefusal("auto", "local is disabled in remote.buildPoolDisabled; enable it or select a machine explicitly");
+}
 function namedBuildMachine(selected) {
 	return selected !== "auto" && selected !== "local";
 }
@@ -703,8 +711,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);
@@ -723,6 +749,176 @@ 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/engine/native-run.ts
+const NATIVE_RUN_LOCK = "native-run";
+const NATIVE_RUN_WAIT_MS = 18e5;
+const WAIT_HEARTBEAT_MS = 3e4;
+const CANCEL_REQUEST_KEY = "nativeRunCancel";
+function nativeRunHolder(holder) {
+	const { command, platform, slot } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default"
+	};
+}
+function describeNativeRunHolder(holder, now) {
+	const { command, slot } = nativeRunHolder(holder);
+	const started = Date.parse(holder.startedAt);
+	const facts = [`pid ${holder.owner.pid}`];
+	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
+	if (command === null) return `another Stim run (${facts.join(", ")})`;
+	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
+}
+/**
+* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
+* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
+*/
+function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
+	let claimId = null;
+	let lastAt = 0;
+	return (holder, firstLine) => {
+		const at = now();
+		if (holder.claimId !== claimId) {
+			claimId = holder.claimId;
+			lastAt = at;
+			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
+			return;
+		}
+		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
+		lastAt = at;
+		write(`still waiting for ${describe(holder, at)}`);
+	};
+}
+/**
+* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
+* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
+* stopped slot is the workspace's only device. A build for another slot that stays is left running and
+* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
+*/
+function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
+	if (holder.command === "macos") {
+		if (stopSlot !== void 0) return { action: "proceed" };
+		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+	}
+	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
+	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
+	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+}
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState$1(root)?.[CANCEL_REQUEST_KEY];
+	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
+	return { pid: request.pid };
+}
+function clearNativeRunCancel(root, claimId) {
+	try {
+		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
+	} catch {}
+}
+let cancelled = null;
+let cancellationSignal;
+/** The active native run aborts this signal when it is cancelled. */
+function runCancellationSignal() {
+	return cancellationSignal;
+}
+/** Why this process's native run was cancelled, or null while it was not. */
+function runCancellation() {
+	return cancelled;
+}
+function cancelledFailure(platform, { code, message }) {
+	if (cancelled === null) return null;
+	return {
+		code: "STIM_CANCELLED",
+		message: `The ${platform} run was ${cancelled} before it finished.`,
+		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
+		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
+	};
+}
+function cancelOnInterrupt({ root, claim, write, exit, controller }) {
+	let signals = 0;
+	const onInterrupt = () => {
+		signals += 1;
+		if (signals > 1) {
+			exit(130);
+			return;
+		}
+		const request = cancelRequestFor(root, claim.claimId);
+		cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		controller.abort();
+		refuseDeclaredSpawns(`the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns("SIGINT");
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+		if (signalled === 0 && !request) exit(130);
+	};
+	process.on("SIGINT", onInterrupt);
+	return () => {
+		process.off("SIGINT", onInterrupt);
+		allowDeclaredSpawns();
+		clearNativeRunCancel(root, claim.claimId);
+	};
+}
+/**
+* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
+* command, platform and slot, and a wait for another holder is reported on `write`. The first SIGINT
+* forwards the interrupt to the running declared build tool; a run `stim stop` cancelled between build
+* tools starts no further one; a terminal interrupt with no build tool running, or a second SIGINT, exits
+* with 130 at once.
+*/
+function withNativeBuildRun(root, details, fn, { write, exit = (code) => process.exit(code) }) {
+	const notice = nativeRunWaitNotice({ write });
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		cancelled = null;
+		const controller = new AbortController();
+		cancellationSignal = controller.signal;
+		const dispose = cancelOnInterrupt({
+			root,
+			claim,
+			write,
+			exit,
+			controller
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			dispose();
+			cancellationSignal = void 0;
+		}
+	}, {
+		external: true,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawns: true,
+		details: { ...details },
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
 //#region src/offload/client.ts
 const CONNECT_TIMEOUT_MS = 1e4;
 const OFFER_TIMEOUT_MS = 2e4;
@@ -750,9 +946,11 @@ function offloadMode(env = process.env) {
 	return OFFLOAD_MODES.includes(raw) ? raw : "auto";
 }
 function buildPlacementCandidates(selected) {
+	const config = loadConfig$1();
 	return {
+		localEnabled: selected !== "auto" || automaticMachineEnabled("build", "local", config),
 		mode: selected === "local" ? "off" : offloadMode(),
-		machines: selected === "local" ? [] : namedBuildMachine(selected) ? pairedMachines([selected]).slice(0, 1) : pairedMachines()
+		machines: selected === "local" ? [] : namedBuildMachine(selected) ? pairedMachines([selected]).slice(0, 1) : pairedMachines().filter((entry) => automaticMachineEnabled("build", entry.machine, config))
 	};
 }
 function remotePhaseText(name, msg, machine) {
@@ -778,41 +976,58 @@ function placementLoad(choice) {
 * this Mac has a free `concurrency.maxBuilds` slot and its load per core is under `server.maxLoadPerCore`.
 * A named selection ignores local capacity and mode, and refuses an unsupported build or missing pairing.
 */
-function offloadPlacement({ mode, machines, here, unsupported, selected = "auto" }) {
+function offloadPlacement({ mode, machines, here, unsupported, localEnabled = true, selected = "auto" }) {
 	if (namedBuildMachine(selected)) {
 		if (unsupported) throw new OffloadRefusal(selected, `${unsupported}, so a named remote Mac cannot take it`);
 		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 (!localEnabled) {
+		const reason = mode === "off" ? "remote.buildMode is off" : unsupported ?? (machines === 0 ? "no enabled remote Mac is paired" : null);
+		if (reason) throw new OffloadRefusal("auto", `${reason}; local is disabled in remote.buildPoolDisabled`);
+		return {
+			offload: true,
+			code: "local-disabled",
+			reason: "local is disabled in remote.buildPoolDisabled"
+		};
+	}
 	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`
 	};
 }
@@ -848,28 +1063,29 @@ function offerProblems(offer, target) {
 * A machine that reports no load (a stim-server older than capacity) takes an `auto` build only while
 * every local slot is busy. The rest rank warmest first, then least loaded.
 */
-function pickOffer({ mode, here, offers, target, selected = "auto" }) {
+function pickOffer({ mode, here, offers, target, localEnabled = true, 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 (selected === "auto" && localEnabled && mode === "auto" && !slotsFull) {
+			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({
@@ -877,13 +1093,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;
 /**
@@ -966,7 +1191,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,
@@ -996,7 +1246,8 @@ var BuildConnection = class BuildConnection {
 						protocol: 1,
 						client: {
 							name: "stim",
-							version: "1"
+							version: "1",
+							runId: runId()
 						},
 						auth: { deviceToken: token }
 					}
@@ -1028,17 +1279,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,
@@ -1048,6 +1318,7 @@ var BuildConnection = class BuildConnection {
 		});
 	}
 	async sendBinary(frame) {
+		if (this.closed) return;
 		this.socket.send(frame, { binary: true });
 		while (this.socket.bufferedAmount > MAX_BUFFERED && !this.closed) await new Promise((resolve) => setTimeout(resolve, 5));
 	}
@@ -1085,6 +1356,14 @@ var BuildConnection = class BuildConnection {
 	}
 	forget() {
 		this.ended = true;
+		this.closed ??= "the connection was closed by this client";
+		for (const resolve of this.pending.values()) resolve({ error: {
+			code: "closed",
+			message: this.closed
+		} });
+		this.pending.clear();
+		this.progress = null;
+		this.binary = null;
 		clearInterval(this.keepalive);
 		this.socket.removeAllListeners("close");
 		openSockets.delete(this.socket);
@@ -1189,7 +1468,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)) {
@@ -1209,7 +1489,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 {
@@ -1218,8 +1498,14 @@ 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({
+	else machines = machines.filter((each) => automaticMachineEnabled("build", each.machine));
+	const rubyVersion = readRubyVersion(projectRoot) ?? void 0;
+	const asked = await Promise.all(machines.map((credential) => probeMachine(credential, {
+		...identity,
+		rubyVersion
+	})));
+	const { order, reasons, candidates } = pickOffer({
+		localEnabled: selected !== "auto" || automaticMachineEnabled("build", "local"),
 		selected,
 		mode,
 		here,
@@ -1233,6 +1519,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) => {
@@ -1249,7 +1536,8 @@ async function chooseBuildMachine({ projectRoot, target, mode, here, note, machi
 		target,
 		offerMs: Date.now() - started,
 		identity,
-		runnersUp: rest
+		runnersUp: rest,
+		automatic: selected === "auto"
 	};
 }
 const ARTIFACT_NAME = {
@@ -1262,7 +1550,7 @@ const ARTIFACT_NAME = {
 * `RESUME_WINDOW_MS`, shorter than the machine's grace for a dropped connection, has passed. Returns why it
 * could not.
 */
-async function resumeJob(credential, job, abandoned) {
+async function resumeJob(credential, job, abandoned, signal) {
 	const deadline = Date.now() + RESUME_WINDOW_MS;
 	let delay = RESUME_DELAY_MS;
 	let last = "no attempt";
@@ -1276,9 +1564,20 @@ async function resumeJob(credential, job, abandoned) {
 			if (connection.refused) return `the machine turned this Mac away (${connection.failure})`;
 			last = connection.failure;
 		} else {
+			if (abandoned()) {
+				connection.close();
+				break;
+			}
 			const early = [];
 			connection.onProgress((event) => early.push(event));
+			const cancel = () => connection.close();
+			signal?.addEventListener("abort", cancel, { once: true });
 			const reply = await connection.request("build.attach", { job }, OFFER_TIMEOUT_MS);
+			signal?.removeEventListener("abort", cancel);
+			if (abandoned()) {
+				connection.close();
+				break;
+			}
 			if ("result" in reply) {
 				const outcome = isJsonObject(reply.result) ? reply.result.outcome : null;
 				return {
@@ -1294,8 +1593,8 @@ async function resumeJob(credential, job, abandoned) {
 			}
 			connection.drop();
 		}
-		if (Date.now() + delay > deadline) break;
-		await new Promise((resolve) => setTimeout(resolve, delay));
+		if (abandoned() || Date.now() + delay > deadline) break;
+		await setTimeout$1(delay, void 0, { signal }).catch(() => {});
 		delay = Math.min(delay * 2, RESUME_MAX_DELAY_MS);
 	}
 	return `no connection to it within ${RESUME_WINDOW_MS / 6e4} min (${last})`;
@@ -1363,23 +1662,36 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			reason: reason.split("\n")[0].slice(0, 300)
 		};
 	};
+	const signal = runCancellationSignal();
+	const throwIfCancelled = () => {
+		if (signal?.aborted) throw Object.assign(/* @__PURE__ */ new Error("The offloaded build was cancelled."), { code: "STIM_CANCELLED" });
+	};
+	let settle;
+	let settled = false;
+	const outcome = new Promise((resolve) => {
+		settle = (value) => {
+			settled = true;
+			resolve(value);
+		};
+	});
+	const cancel = () => {
+		settle({
+			ok: false,
+			code: "cancelled"
+		});
+		closeOffload(choice);
+	};
+	signal?.addEventListener("abort", cancel, { once: true });
 	try {
+		throwIfCancelled();
 		let job = null;
 		let early = [];
-		let settle;
-		let settled = false;
-		const outcome = new Promise((resolve) => {
-			settle = (value) => {
-				settled = true;
-				resolve(value);
-			};
-		});
 		let resuming = false;
 		const reattach = async (why) => {
 			if (resuming || settled) return;
 			resuming = true;
 			note(`offload: the connection to ${choice.machine} dropped (${why}); reattaching to the build there`);
-			const resumed = await resumeJob(choice.credential, job, () => settled);
+			const resumed = await resumeJob(choice.credential, job, () => settled, signal);
 			resuming = false;
 			if (settled) {
 				if (typeof resumed !== "string") resumed.connection.close();
@@ -1422,7 +1734,13 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			return true;
 		};
 		for (;;) {
+			if (choice.automatic && !automaticMachineEnabled("build", choice.machine)) {
+				const reason = `${choice.machine} is disabled in remote.buildPoolDisabled`;
+				if (moveOn(reason)) continue;
+				return fail(reason);
+			}
 			const synced = await syncSource(choice.connection, identity, onEnter);
+			throwIfCancelled();
 			if ("failure" in synced) {
 				if (moveOn(synced.failure)) continue;
 				return fail(synced.failure);
@@ -1432,6 +1750,8 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			workerStarted = Date.now();
 			early = [];
 			choice.connection.onProgress((event) => job === null ? early.push(event) : handle(event));
+			if (choice.automatic) requireAutomaticMachine("build", choice.machine);
+			throwIfCancelled();
 			const reply = await choice.connection.request("build.start", {
 				repo: identity.repo,
 				project: identity.project,
@@ -1454,6 +1774,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 				},
 				stimBuild: choice.target.local.stimBuild
 			});
+			throwIfCancelled();
 			if ("result" in reply) {
 				job = reply.result.job;
 				break;
@@ -1471,6 +1792,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 		}), JOB_TIMEOUT_MS);
 		const result = await outcome;
 		clearTimeout(timer);
+		throwIfCancelled();
 		const { connection, machine } = choice;
 		connection.onProgress(null);
 		const workerMs = Date.now() - workerStarted;
@@ -1479,6 +1801,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 		const name = typeof artifact?.name === "string" ? artifact.name : "";
 		if (!ARTIFACT_NAME[request.platform].test(name) || typeof artifact.sha256 !== "string") return fail(`the machine reported no .${request.platform === "android" ? "apk" : "app"} artifact`);
 		onEnter("fetch");
+		throwIfCancelled();
 		const fetchStarted = Date.now();
 		rmSync(stagingDir, {
 			recursive: true,
@@ -1508,6 +1831,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 		const fetched = await connection.request("build.artifact", { job }, 9e5);
 		connection.onBinary(null);
 		closeSync(fd);
+		throwIfCancelled();
 		const fetchFailure = replyError(fetched);
 		if (fetchFailure || !("result" in fetched)) return fail(`fetch: ${fetchFailure ?? "no reply"}`);
 		const digest = hash.digest("hex");
@@ -1520,6 +1844,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			"-C",
 			stagingDir
 		], { timeoutMs: 6e5 });
+		throwIfCancelled();
 		rmSync(archive, { force: true });
 		const artifactPath = join(stagingDir, name);
 		if (request.platform === "ios" && !existsSync(join(artifactPath, "Info.plist"))) return fail(`fetch: ${name} has no Info.plist`);
@@ -1556,7 +1881,11 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			}
 		};
 	} catch (error) {
+		closeOffload(choice);
+		throwIfCancelled();
 		return fail(error.message.split("\n")[0] ?? String(error));
+	} finally {
+		signal?.removeEventListener("abort", cancel);
 	}
 }
 function packageName(projectRoot) {
@@ -1634,7 +1963,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
 		});
@@ -1662,4 +1994,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 { resolveBuildPlacement as A, setRemoteLogSink as C, parseBuildMachineOption as D, namedBuildMachine as E, parseMachine$1 as F, pinnedEndpoint$1 as I, realIo as L, configuredMachines as M, hostingMachines as N, requireLocalBuild as O, inspectDeviceHostMachines as P, withNativeBuildRun as S, buildPlacementSettings as T, nativeRunHolder as _, offloadBuild as a, runCancellation as b, placementLoad as c, NATIVE_RUN_LOCK as d, NATIVE_RUN_WAIT_MS as f, describeNativeRunHolder as g, decideStopAction as h, closeOffload as i, inspectBuildMachines as j, resolveBuildMachine as k, remotePhaseText as l, clearNativeRunCancel as m, buildPlacementCandidates as n, offloadCheck as o, cancelledFailure as p, chooseBuildMachine as r, offloadPlacement as s, BuildConnection as t, simulatorRuntime as u, nativeRunWaitNotice as v, OffloadRefusal as w, runCancellationSignal as x, requestNativeRunCancel as y };