stim 1.20.2 → 1.22.0

package/dist/client-qQAaXSUs.mjs

@@ -1,1771 +0,0 @@
-import { _ as loadConfig$1, d as getConfigDir } from "./config-BYDxlMY3.mjs";
-import { r as debugLog, t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { t as git } from "./git-DDfFzkMm.mjs";
-import { D as withDirLock } from "./workspace-state-DJt_MMvf.mjs";
-import { a as markApproved, c as pinnedEndpoint$1, i as lapsedLine, l as realIo, n as findPeer$1, o as parseMachine$1, r as isLapsed, s as pendingReport, t as endpoint, u as requestedLine, x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { r as throwIfCancelled } from "./cancellation-C_22VQTH.mjs";
-import { n as CCACHE_UNAVAILABLE } from "./ccache-zdKiYQ3E.mjs";
-import { l as toolchainMismatches, m as readRubyVersion, v as COMPILATION_CACHE_UNAVAILABLE } from "./toolchain-DxSsNssu.mjs";
-import { c as gitVisiblePaths, i as nativeGradleTransfer, l as nativeTransferManifest, m as manifestDigest, s as checkNativeTransferMembership, u as sourceManifest } from "./native-gradle-inputs-BsLRrl7u.mjs";
-import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync, writeSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
-import { OFFLOAD_MODES, acceptsShape, automaticMachineEnabled, buildMachinesFile, buildMachinesLock, deviceHostMachinesClaims, deviceHostMachinesFile, deviceHostMachinesLock, isJsonObject, parseMachine, readBuildMachines, readDeviceHostMachines, requireAutomaticMachine, runId, saturation, settingDefinition } from "@stim-cli/core/state";
-import { InvalidArgumentError } from "commander";
-import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
-import { createHash } from "node:crypto";
-import { hostname } from "node:os";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { WebSocket } from "ws";
-//#region src/offload/access-ticket.ts
-function readAccessTicket() {
-	const ticket = process.env.STIM_ACCESS_TICKET?.trim();
-	return ticket && /^[A-Za-z0-9_-]{43}$/.test(ticket) ? {
-		ticket,
-		ticketHash: createHash("sha256").update(ticket).digest("hex")
-	} : void 0;
-}
-function readHostPermissions(value) {
-	const host = value;
-	return host && typeof host.name === "string" && typeof host.screenRecording === "boolean" && typeof host.accessibility === "boolean" ? {
-		name: host.name,
-		screenRecording: host.screenRecording,
-		accessibility: host.accessibility
-	} : void 0;
-}
-//#endregion
-//#region src/device-host/machines.ts
-function note$1(title, detail, fix = null) {
-	return {
-		code: "device-host-machine",
-		level: "note",
-		title,
-		detail,
-		fix
-	};
-}
-const approval$1 = (machine, id) => `A person on ${machine} approves it with \`stim-server devices grant ${id} --device-host\`.`;
-function configuredMachines() {
-	const remote = loadConfig$1()?.remote;
-	if (remote !== void 0 && !isJsonObject(remote)) return null;
-	const machines = remote?.machines;
-	if (machines === void 0) return [];
-	return acceptsShape(settingDefinition("remote.machines"), machines) ? machines : null;
-}
-/** The `remote.machines` entries this Mac asked for device-host access, in setting order; null when the setting is invalid. */
-function hostingMachines() {
-	const configured = configuredMachines();
-	if (configured === null) return null;
-	try {
-		const asked = readDeviceHostMachines();
-		return configured.filter((machine) => asked.some((each) => each.machine === machine));
-	} catch {
-		return configured;
-	}
-}
-function store(machines) {
-	withDirLock(deviceHostMachinesLock(), () => {
-		const file = deviceHostMachinesFile();
-		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-		try {
-			writeFileSync(tmp, `${JSON.stringify({
-				version: 1,
-				machines
-			}, null, 2)}\n`, { mode: 384 });
-			renameSync(tmp, file);
-		} finally {
-			rmSync(tmp, { force: true });
-		}
-	}, { ensureParent: () => mkdirSync(getConfigDir(), { recursive: true }) });
-}
-async function request(machine, peer, port, deviceName, io) {
-	const ticket = readAccessTicket();
-	const reply = await io.hello(endpoint(peer, port), {
-		request: "device-host",
-		deviceName,
-		...ticket ? { setupTicket: ticket.ticket } : {}
-	});
-	if (!("result" in reply) || reply.result?.approval?.state !== "pending" || typeof reply.result.deviceToken !== "string" || !reply.result.deviceToken || typeof reply.result.device?.id !== "string" || !reply.result.device.id || typeof reply.result.approval.expiresAt !== "string" || !reply.result.approval.expiresAt) return {
-		report: {
-			machine,
-			dnsName: peer.dnsName,
-			state: "unreachable"
-		},
-		finding: note$1(`Could not ask ${machine} for hosting access`, "The worker did not return a pending request.")
-	};
-	const credential = {
-		machine,
-		nodeId: peer.nodeId,
-		dnsName: peer.dnsName,
-		deviceId: reply.result.device.id,
-		deviceToken: reply.result.deviceToken,
-		state: "pending",
-		requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		expiresAt: reply.result.approval.expiresAt,
-		...ticket ? { ticketHash: ticket.ticketHash } : {}
-	};
-	return {
-		report: {
-			machine,
-			dnsName: peer.dnsName,
-			state: "pending",
-			deviceId: credential.deviceId,
-			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
-	};
-}
-/** Reports the device-host approval of each remote Mac, separate from its build approval. Only --fix asks or forgets credentials; every token stays pinned. */
-async function inspectDeviceHostMachines({ fix }, io = realIo, entries = configuredMachines()) {
-	if (entries === null) return {
-		findings: [note$1("Invalid remote.machines setting", "Use a remote object with machines as an array of tailnet names. Existing hosting credentials and pinned nodes are preserved.", "Run `stim guide settings` and correct the setting before running doctor again.")],
-		machines: []
-	};
-	const unavailable = (state, finding) => ({
-		findings: [finding],
-		machines: entries.map((machine) => ({
-			machine,
-			state
-		}))
-	});
-	const unreadable = () => unavailable("credentials-unavailable", note$1("Hosting credentials are unreadable", `Stim preserves ${deviceHostMachinesFile()} and its pinned nodes.`, "Restore the existing file from a trusted backup or restore read access before running doctor again."));
-	if (!entries.length) {
-		if (!fix) return {
-			findings: [],
-			machines: []
-		};
-		try {
-			if (!readDeviceHostMachines().length) return {
-				findings: [],
-				machines: []
-			};
-		} catch {
-			return unreadable();
-		}
-	}
-	const claim = tryAcquireClaim({
-		root: deviceHostMachinesClaims(),
-		mode: "exclusive",
-		label: "device-host approval"
-	});
-	if (!claim.acquired) {
-		releaseClaim(claim.pending);
-		return unavailable("busy", note$1("Device-host approval is in use", "Another doctor run holds the hosting credential claim. Run doctor again after it finishes."));
-	}
-	try {
-		let credentials;
-		try {
-			credentials = readDeviceHostMachines();
-		} catch {
-			return unreadable();
-		}
-		if (fix) {
-			const kept = credentials.filter((each) => entries.includes(each.machine));
-			if (kept.length !== credentials.length) {
-				store(kept);
-				credentials = kept;
-			}
-		}
-		if (!entries.length) return {
-			findings: [],
-			machines: []
-		};
-		const status = io.status();
-		if (!isJsonObject(status)) return unavailable("tailscale-off", note$1("Remote Macs are unreachable", "remote.machines names remote Macs, but Tailscale is not running."));
-		const self = isJsonObject(status.Self) ? status.Self : {};
-		const deviceName = (typeof self.HostName === "string" && self.HostName ? self.HostName : hostname()).replace(/[\p{Cc}\p{Cf}]/gu, "").trim().slice(0, 64) || "Mac";
-		const inspected = {
-			findings: [],
-			machines: []
-		};
-		const namedNodes = /* @__PURE__ */ new Set();
-		for (const machine of new Set(entries)) {
-			const parsed = parseMachine$1(machine);
-			if (!parsed) {
-				inspected.machines.push({
-					machine,
-					state: "invalid"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} is not a tailnet name`, "Expected `name` or `name:port`."));
-				continue;
-			}
-			const current = io.status();
-			if (!isJsonObject(current)) {
-				inspected.machines.push({
-					machine,
-					state: "tailscale-off"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} is unreachable`, "Tailscale stopped before this connection."));
-				continue;
-			}
-			const peer = findPeer$1(current, parsed.name);
-			if (peer === "missing" || peer === "ambiguous") {
-				inspected.machines.push({
-					machine,
-					state: "not-on-tailnet"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} is not on this tailnet`, peer === "missing" ? "No peer has that name." : "Several peers match that name."));
-				continue;
-			}
-			const nodeRoute = `${peer.nodeId}:${parsed.port}`;
-			if (namedNodes.has(nodeRoute)) {
-				inspected.machines.push({
-					machine,
-					dnsName: peer.dnsName,
-					state: "invalid"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} repeats a named node`, "Name each tailnet node and serve port only once in remote.machines."));
-				continue;
-			}
-			namedNodes.add(nodeRoute);
-			const credential = credentials.find((each) => each.machine === machine);
-			const known = {
-				machine,
-				dnsName: peer.dnsName,
-				...credential ? {
-					deviceId: credential.deviceId,
-					requestedAt: credential.requestedAt
-				} : {}
-			};
-			if (credential && credential.nodeId !== peer.nodeId) {
-				inspected.machines.push({
-					...known,
-					state: "node-changed"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} is a different tailnet node`, "Stim refuses to connect or send the saved token.", `If that Mac was replaced, remove ${machine} from remote.machines, run \`stim doctor --fix\`, then add it back and run \`stim doctor --fix\` again to request approval on the new node.`));
-				continue;
-			}
-			let ask = !credential && fix;
-			if (credential) {
-				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 ? markApproved(each) : each);
-						store(credentials);
-					}
-					const host = readHostPermissions(reply.result.host);
-					if (host && (host.screenRecording === false || host.accessibility === false)) {
-						const panes = [...host.screenRecording === false ? ["Screen & System Audio Recording (Screen Recording on macOS 14)"] : [], ...host.accessibility === false ? ["Device Control and Data Access (Accessibility on macOS 26 and earlier)"] : []];
-						const detail = [...host.screenRecording === false ? ["Viewing hosted macOS apps needs Screen Recording."] : [], ...host.accessibility === false ? ["Controlling them needs the control permission."] : []];
-						inspected.findings.push(note$1(`Remote Mac ${machine} needs ${panes.join(" and ")} for ${host.name}`, detail.join(" "), `On ${machine}, approve ${host.name} in System Settings > Privacy & Security, or run \`stim-server service install\` there again to show the requests.`));
-					}
-					inspected.machines.push({
-						...known,
-						state: "approved",
-						...host ? { host } : {}
-					});
-					continue;
-				}
-				const pending = "error" in reply && reply.error?.code === "approval-pending";
-				const revoked = "error" in reply && reply.error?.code === "unauthorized";
-				const ticket = fix && pending && credential.state !== "approved" ? readAccessTicket() : void 0;
-				ask = fix && (revoked || !!ticket && credential.ticketHash !== ticket.ticketHash);
-				if (pending && !ask) {
-					inspected.machines.push({
-						...known,
-						...pendingReport(credential)
-					});
-					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: lapsed ? "lapsed" : revoked ? "revoked" : "unreachable"
-					});
-					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;
-				}
-			}
-			if (ask) {
-				const result = await request(machine, peer, parsed.port, deviceName, io);
-				if (result.credential) {
-					credentials = [...credentials.filter((each) => each.machine !== machine), result.credential];
-					store(credentials);
-				}
-				inspected.machines.push(result.report);
-				inspected.findings.push(result.finding);
-			} else {
-				inspected.machines.push({
-					...known,
-					state: "not-asked"
-				});
-				inspected.findings.push(note$1(`Remote Mac ${machine} has not approved this Mac for device hosting`, "This Mac has not asked for hosting access.", "Run `stim doctor --fix` to ask."));
-			}
-		}
-		return inspected;
-	} finally {
-		releaseClaim(claim.acquired);
-	}
-}
-//#endregion
-//#region src/offload/build-machines.ts
-/** The `remote.machines` entries that this Mac asked for build access, in that order. */
-function pairedMachines(entries = configuredMachines() ?? []) {
-	const credentials = readBuildMachines();
-	return entries.flatMap((entry) => credentials.filter((each) => each.machine === entry));
-}
-function updateCredentials(change) {
-	const dir = getConfigDir();
-	withDirLock(buildMachinesLock(), () => {
-		const file = buildMachinesFile();
-		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify({
-			version: 1,
-			machines: change(readBuildMachines())
-		}, null, 2)}\n`, { mode: 384 });
-		try {
-			renameSync(tmp, file);
-		} catch (error) {
-			rmSync(tmp, { force: true });
-			throw error;
-		}
-	}, { ensureParent: () => mkdirSync(dir, { recursive: true }) });
-}
-function note(title, detail, fix = null) {
-	return {
-		code: "build-machine",
-		level: "note",
-		title,
-		detail,
-		fix
-	};
-}
-const approval = (entry, deviceId) => `A person on ${entry} approves it with \`stim-server devices grant ${deviceId} --build\`.`;
-const PROBLEM_TITLES = {
-	unreachable: "does not answer a build offer",
-	checkout: "cannot build an app outside a git checkout",
-	"stim-build": "runs another Stim build",
-	arch: "has another CPU architecture",
-	xcode: "has another Xcode",
-	"macos-sdk": "has another macOS SDK",
-	"simulator-sdk": "has another simulator SDK",
-	cocoapods: "has another CocoaPods",
-	bundler: "has no Bundler",
-	runtime: "has no simulator for this project's iOS runtime",
-	jdk: "runs another JDK major version",
-	"android-sdk": "has no Android SDK",
-	ndk: "lacks this project's NDK",
-	"build-tools": "lacks this project's Android build-tools",
-	"compile-sdk": "lacks this project's Android compile platform",
-	disk: "is low on disk",
-	busy: "is too busy to take builds"
-};
-function problemFix(code, entry) {
-	switch (code) {
-		case "unreachable": return `Check that stim-server runs on ${entry} and that its tailscale serve route answers, then run \`stim doctor\` again. To keep it running there, run \`stim-server service install --serve\` on ${entry}.`;
-		case "checkout": return "Offload syncs the files git lists; run Stim from a git checkout of the app.";
-		case "stim-build": return `Update stim-server on ${entry} to the same Stim build as this Mac: there, run \`stim-server service update --release <version>\` for this Mac's release, or \`--from <dir>\` with the packed packages of this Mac's checkout.`;
-		case "arch": return "Use a remote Mac with the same CPU architecture as this Mac.";
-		case "xcode":
-		case "simulator-sdk":
-		case "macos-sdk": return `Install and select the same Xcode on ${entry} and this Mac (\`xcode-select -p\` on each).`;
-		case "cocoapods": return `Install the same CocoaPods version on ${entry}, on the PATH its stim-server's login shell sets.`;
-		case "bundler": return `Install Bundler (\`gem install bundler\`) on ${entry}, on the PATH its stim-server's login shell sets.`;
-		case "runtime": return `Install that iOS simulator runtime on ${entry} with at least one iPhone simulator, or set ios.runtime here to one ${entry} has.`;
-		case "jdk": return `Start stim-server on ${entry} with JAVA_HOME at a JDK of the same major version as this Mac's.`;
-		case "android-sdk":
-		case "ndk":
-		case "build-tools":
-		case "compile-sdk": return `Install the missing package with sdkmanager in the Android SDK stim-server on ${entry} uses (its ANDROID_HOME, else ~/Library/Android/sdk).`;
-		case "disk": return `Free space on ${entry}'s worker root (server.workerRoot there).`;
-		case "busy": return `Builds stay on this Mac until ${entry} has capacity. On ${entry}, server.maxLoadPerCore sets the load it accepts and concurrency.maxBuilds how many of its own builds it runs; it takes one offloaded build at a time.`;
-	}
-}
-const TRANSIENT = /* @__PURE__ */ new Set(["unreachable", "busy"]);
-function offloadFindings(entry, problems) {
-	return problems.map((problem) => ({
-		code: `build-machine-${problem.code}`,
-		level: TRANSIENT.has(problem.code) ? "note" : "cost",
-		title: `Remote Mac ${entry} ${PROBLEM_TITLES[problem.code]}`,
-		detail: `Builds fall back to this Mac: ${problem.reason}.`,
-		fix: problemFix(problem.code, entry)
-	}));
-}
-async function requestAccess(entry, peer, port, deviceName, io) {
-	const ticket = readAccessTicket();
-	const reply = await io.hello(endpoint(peer, port), {
-		request: "build",
-		deviceName,
-		...ticket ? { setupTicket: ticket.ticket } : {}
-	});
-	if (!("result" in reply) || !reply.result.approval || !reply.result.deviceToken) {
-		const reason = "failed" in reply ? reply.failed : "error" in reply ? reply.error.message : "it granted no request";
-		return {
-			report: {
-				machine: entry,
-				state: "unreachable",
-				dnsName: peer.dnsName
-			},
-			finding: note(`Could not ask ${entry} for build access`, reason)
-		};
-	}
-	const credential = {
-		machine: entry,
-		nodeId: peer.nodeId,
-		dnsName: peer.dnsName,
-		deviceId: reply.result.device.id,
-		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]);
-	return {
-		report: {
-			machine: entry,
-			state: "pending",
-			dnsName: peer.dnsName,
-			deviceId: credential.deviceId,
-			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))
-	};
-}
-async function inspectMachine(entry, status, deviceName, fix, io, check) {
-	const parsed = parseMachine$1(entry);
-	if (!parsed) return {
-		report: {
-			machine: entry,
-			state: "invalid"
-		},
-		finding: note(`Remote Mac ${entry} is not a tailnet name`, "Expected `name` or `name:port`.")
-	};
-	const peer = findPeer$1(status, parsed.name);
-	if (peer === "missing" || peer === "ambiguous") {
-		const detail = peer === "missing" ? "No peer on this tailnet has that name." : "Several peers match that name.";
-		return {
-			report: {
-				machine: entry,
-				state: "not-on-tailnet"
-			},
-			finding: note(`Remote Mac ${entry} is not on this tailnet`, detail)
-		};
-	}
-	const credential = readBuildMachines().find((each) => each.machine === entry);
-	const known = {
-		machine: entry,
-		dnsName: peer.dnsName
-	};
-	if (credential && credential.nodeId !== peer.nodeId) return {
-		report: {
-			...known,
-			state: "node-changed",
-			deviceId: credential.deviceId,
-			requestedAt: credential.requestedAt
-		},
-		finding: note(`Remote Mac ${entry} is a different tailnet node`, `This Mac paired with node ${credential.nodeId}, but ${peer.dnsName} is now node ${peer.nodeId}. Stim does not connect to it.`, `If that Mac was replaced, remove ${entry} from remote.machines, run \`stim doctor --fix\` to forget the old pairing, then add it back and run \`stim doctor --fix\` again.`)
-	};
-	if (!credential) {
-		if (fix) return requestAccess(entry, peer, parsed.port, deviceName, io);
-		return {
-			report: {
-				...known,
-				state: "not-asked"
-			},
-			finding: note(`Remote Mac ${entry} has not approved this Mac for builds`, "This Mac has not asked it for build access.", "Run `stim doctor --fix` to ask.")
-		};
-	}
-	const paired = {
-		...known,
-		deviceId: credential.deviceId,
-		requestedAt: credential.requestedAt
-	};
-	const reply = await io.hello(endpoint(peer, parsed.port), { deviceToken: credential.deviceToken });
-	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 ? markApproved(each) : each));
-		if (!check) return {
-			report: {
-				...paired,
-				state: "approved",
-				...host
-			},
-			finding: null
-		};
-		const { capacity, problems } = await check({
-			...credential,
-			state: "approved"
-		});
-		return {
-			report: {
-				...paired,
-				state: "approved",
-				...host,
-				offloadable: problems.length === 0,
-				reasons: problems.map((problem) => problem.reason),
-				problems,
-				...capacity ? { capacity } : {}
-			},
-			finding: null,
-			extra: offloadFindings(entry, problems)
-		};
-	}
-	if ("error" in reply && reply.error.code === "approval-pending") {
-		const ticket = fix && credential.state !== "approved" ? readAccessTicket() : void 0;
-		if (ticket && credential.ticketHash !== ticket.ticketHash) return requestAccess(entry, peer, parsed.port, deviceName, io);
-		return {
-			report: {
-				...paired,
-				...pendingReport(credential)
-			},
-			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 denied.`, "Run `stim doctor --fix` to ask again.")
-		};
-	}
-	const reason = "failed" in reply ? reply.failed : "error" in reply ? reply.error.message : "unexpected reply";
-	return {
-		report: {
-			...paired,
-			state: "unreachable"
-		},
-		finding: note(`Could not reach remote Mac ${entry}`, reason, `Check that stim-server runs on ${entry}. To keep it running there, run \`stim-server service install --serve\` on ${entry}.`)
-	};
-}
-/**
-* Doctor findings and a report for each `remote.machines` entry. The worker's node is pinned when access is
-* requested; a later connection goes only to the current MagicDNS name of that same node, checked before the token
-* is sent. With `fix`, requests access from a named machine this Mac holds no pairing for, requests again when the
-* pinned node forgot this Mac or, with `STIM_ACCESS_TICKET` set, when a pending request carries another ticket, and forgets pairings of machines no longer named. With `check`, each approved
-* machine is asked for one build offer and reports every reason it would not take this project's build.
-*/
-async function inspectBuildMachines({ fix, check = null }, io = realIo, entries = configuredMachines()) {
-	if (entries === null) return {
-		findings: [note("Invalid remote.machines setting", "Use a remote object with machines as an array of tailnet names. Existing credentials and pinned nodes are preserved.", "Run `stim guide settings` and correct the setting before running doctor again.")],
-		machines: []
-	};
-	const unnamed = (each) => !entries.includes(each.machine);
-	if (fix && readBuildMachines().some(unnamed)) updateCredentials((credentials) => credentials.filter((each) => !unnamed(each)));
-	if (entries.length === 0) return {
-		findings: [],
-		machines: []
-	};
-	const status = io.status();
-	if (!isJsonObject(status)) return {
-		findings: [note("Remote Macs are unreachable", "remote.machines names remote Macs, but Tailscale is not running.")],
-		machines: entries.map((machine) => ({
-			machine,
-			state: "tailscale-off"
-		}))
-	};
-	const self = isJsonObject(status.Self) ? status.Self : {};
-	const deviceName = (typeof self.HostName === "string" && self.HostName ? self.HostName : hostname()).replace(/[\p{Cc}\p{Cf}]/gu, "").trim().slice(0, 64) || "Mac";
-	const inspection = {
-		findings: [],
-		machines: []
-	};
-	const inspected = await Promise.all(entries.map((entry) => inspectMachine(entry, status, deviceName, fix, io, check)));
-	for (const { report, finding, extra = [] } of inspected) {
-		inspection.machines.push(report);
-		if (finding) inspection.findings.push(finding);
-		inspection.findings.push(...extra);
-	}
-	return inspection;
-}
-//#endregion
-//#region src/offload/selection.ts
-var OffloadRefusal = class extends Error {
-	code = "STIM_OFFLOAD_REFUSED";
-	remedy = "Run stim doctor --fix to ask for build access if not paired. On the worker, a person finds the id with stim-server devices and approves it with stim-server devices grant <id> --build. Check stim settings get remote.machines, or rerun with --remote-build auto or --remote-build local.";
-	constructor(machine, reason) {
-		super(reason.startsWith(`${machine}: `) ? reason : `${machine}: ${reason}`);
-	}
-};
-function resolveBuildMachine(flag, env, setting) {
-	const selected = flag ?? (env?.trim() || void 0) ?? setting ?? "auto";
-	if (typeof selected !== "string" || !selected.trim() || !parseMachine(selected)) throw Object.assign(/* @__PURE__ */ new Error("--remote-build / remote.build must be auto, local, or a tailnet machine name."), { code: "STIM_BAD_ARG" });
-	const trimmed = selected.trim();
-	const reserved = trimmed.toLowerCase();
-	return reserved === "auto" || reserved === "local" ? reserved : trimmed;
-}
-function parseBuildMachineOption(value) {
-	try {
-		return resolveBuildMachine(value);
-	} catch (error) {
-		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";
-}
-function requireConfiguredMachine(selected, machines) {
-	if (!namedBuildMachine(selected)) return selected;
-	const parsed = parseMachine(selected);
-	const entries = Array.isArray(machines) ? machines.filter((entry) => typeof entry === "string") : [];
-	const match = entries.find((entry) => {
-		const candidate = parseMachine(entry);
-		return candidate?.name === parsed.name && candidate.port === parsed.port;
-	});
-	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);
-		selected = requireConfiguredMachine(selected, remote?.machines);
-		if (namedBuildMachine(selected) && pairedMachines([selected]).length === 0) throw new OffloadRefusal(selected, "no remote Mac is paired");
-		return { selected };
-	} catch (error) {
-		return {
-			selected,
-			failure: {
-				code: error.code,
-				message: error.message,
-				remedy: error instanceof OffloadRefusal ? error.remedy : "Pass --remote-build auto, local, or an entry from stim settings get remote.machines."
-			}
-		};
-	}
-}
-//#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;
-const REQUEST_TIMEOUT_MS = 12e4;
-const JOB_TIMEOUT_MS = 39e5;
-const PING_MS = 15e3;
-const SILENT_MS = 6e4;
-const CLOSE_TIMEOUT_MS = 2e3;
-const CLOSE_ABNORMAL = 1006;
-const TURNED_AWAY = /* @__PURE__ */ new Set([
-	"unauthorized",
-	"forbidden",
-	"approval-pending",
-	"protocol-unsupported"
-]);
-const RESUME_WINDOW_MS = 18e4;
-const RESUME_DELAY_MS = 2e3;
-const RESUME_MAX_DELAY_MS = 15e3;
-const PAGE_BYTES = 49152;
-const CHUNK_BYTES = 61440;
-const MAX_BUFFERED = 8388608;
-const DIGEST_BYTES = 32;
-function offloadMode(env = process.env) {
-	const raw = env.STIM_REMOTE_BUILD_MODE || loadConfig$1()?.remote?.buildMode;
-	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().filter((entry) => automaticMachineEnabled("build", entry.machine, config))
-	};
-}
-function remotePhaseText(name, msg, machine) {
-	const text = msg.trim();
-	return `${text.startsWith(`${name} `) ? text.slice(name.length).trimStart() : text} (on ${machine})`;
-}
-const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
-function capacityText(capacity) {
-	const builds = capacity.maxBuilds > 0 ? `${capacity.builds} of ${capacity.maxBuilds} build slots busy` : plural(capacity.builds, "build");
-	return `load ${capacity.loadPerCore}/core, ${builds}`;
-}
-function placementLoad(choice) {
-	const { loadPerCore, builds, maxBuilds } = choice.offer.capacity;
-	if (typeof loadPerCore !== "number" || typeof builds !== "number") return "";
-	return `; ${capacityText({
-		loadPerCore,
-		builds,
-		maxBuilds: maxBuilds ?? 0
-	})} there`;
-}
-/**
-* Whether a build may go to a remote Mac at all, before any machine is asked. `auto` keeps the build here while
-* 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, 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`
-	};
-}
-const gb = (bytes) => (bytes / 1024 ** 3).toFixed(1);
-/** Every reason a machine's offer cannot take this build, in either mode; empty when it can. */
-function offerProblems(offer, target) {
-	const problems = toolchainMismatches(target, offer.toolchain);
-	const capacity = offer.capacity;
-	const { running, max, diskFreeBytes, minDiskFreeBytes, declined } = capacity;
-	if (diskFreeBytes !== null && diskFreeBytes < minDiskFreeBytes) problems.push({
-		code: "disk",
-		reason: `${gb(diskFreeBytes)} GB free, needs ${gb(minDiskFreeBytes)} GB`
-	});
-	else if (declined || declined === void 0 && running >= max) {
-		const why = declined ?? `already running ${running} offloaded build(s), its limit`;
-		const load = typeof capacity.loadPerCore === "number" && typeof capacity.builds === "number" ? `; ${capacityText({
-			loadPerCore: capacity.loadPerCore,
-			builds: capacity.builds,
-			maxBuilds: capacity.maxBuilds ?? 0
-		})}` : "";
-		problems.push({
-			code: "busy",
-			reason: `busy (${why}${load})`
-		});
-	}
-	return problems;
-}
-/**
-* The asked machines that can take the build, best first, and one reason per machine that cannot. A machine with any
-* `offerProblems` never takes it. In `auto`, a machine must also be expected to build faster than this Mac: while
-* every local build slot is busy any machine that accepts will do, otherwise its load per core must be lower than
-* this Mac's. A named selection considers only that machine and skips this local-capacity gating.
-* 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, 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 skip(machine, "unreachable", failure ?? "no offer");
-		const problems = offerProblems(offer, target);
-		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" && 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({
-			index,
-			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,
-		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;
-/**
-* A close frame on every connection still open when this process exits, as on an interrupt, so the machine cancels
-* its builds instead of keeping them for a new connection.
-*/
-function closeOnExit(socket) {
-	if (!closingOnExit) {
-		closingOnExit = true;
-		process.once("exit", () => {
-			for (const each of openSockets) each.close(1e3);
-		});
-	}
-	openSockets.add(socket);
-	socket.once("close", () => openSockets.delete(socket));
-}
-/**
-* One authenticated connection to another Mac's stim-server, for build offload or device hosting. Closing it cancels
-* its build jobs there; a connection that drops, or that stays silent for `SILENT_MS` after `watch()`, leaves them
-* running for a while so a new connection can `build.attach` to them.
-*/
-var BuildConnection = class BuildConnection {
-	nextId = 2;
-	pending = /* @__PURE__ */ new Map();
-	progress = null;
-	binary = null;
-	closed = null;
-	heard = Date.now();
-	watched = false;
-	ended = false;
-	keepalive;
-	socket;
-	features;
-	constructor(socket, features) {
-		this.socket = socket;
-		this.features = features;
-		closeOnExit(socket);
-		this.keepalive = setInterval(() => {
-			if (this.watched && Date.now() - this.heard > SILENT_MS) return void socket.terminate();
-			socket.ping();
-		}, PING_MS);
-		this.keepalive.unref();
-		socket.on("pong", () => this.heard = Date.now());
-		socket.on("message", (data, isBinary) => {
-			this.heard = Date.now();
-			const frame = Buffer.isBuffer(data) ? data : Buffer.concat(Array.isArray(data) ? data : [Buffer.from(data)]);
-			if (isBinary) return this.binary?.(frame);
-			let message;
-			try {
-				message = JSON.parse(frame.toString("utf8"));
-			} catch {
-				return;
-			}
-			if (!isJsonObject(message)) return;
-			if (message.event === "build.progress") return this.progress?.(message);
-			const resolve = typeof message.id === "number" ? this.pending.get(message.id) : void 0;
-			if (resolve) {
-				this.pending.delete(message.id);
-				resolve(message);
-			}
-		});
-		socket.on("close", (code, reason) => {
-			clearInterval(this.keepalive);
-			this.closed = `the connection closed (${code}${reason.length ? ` ${reason.toString()}` : ""})`;
-			for (const resolve of this.pending.values()) resolve({ error: {
-				code: "closed",
-				message: this.closed
-			} });
-			this.pending.clear();
-			const dropped = code === CLOSE_ABNORMAL;
-			this.progress?.({
-				job: "",
-				outcome: {
-					ok: false,
-					code: dropped ? "dropped" : "closed",
-					message: this.closed
-				}
-			});
-		});
-		socket.on("error", () => {});
-	}
-	/** Resolves why it could not connect; `refused` when the machine answered and turned this Mac away. */
-	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,
-				servername: target.servername,
-				headers: { Host: target.host }
-			};
-			const socket = new WebSocket(target.url, options);
-			const fail = (reason, refused = false, code) => {
-				clearTimeout(timer);
-				socket.removeAllListeners();
-				socket.on("error", () => {});
-				socket.terminate();
-				resolve({
-					failure: reason,
-					refused,
-					...code ? { code } : {}
-				});
-			};
-			const timer = setTimeout(() => fail("no reply in time"), timeoutMs);
-			socket.once("error", (error) => fail(/Unexpected server response: 502/.test(error.message) ? "no stim-server answers behind its tailscale serve route (HTTP 502)" : error.message));
-			socket.once("close", () => fail("the connection closed before hello"));
-			socket.once("open", () => {
-				socket.send(JSON.stringify({
-					id: 1,
-					method: "hello",
-					params: {
-						protocol: 1,
-						client: {
-							name: "stim",
-							version: "1",
-							runId: runId()
-						},
-						auth: { deviceToken: token }
-					}
-				}));
-			});
-			socket.once("message", (data) => {
-				clearTimeout(timer);
-				socket.removeAllListeners();
-				let reply;
-				try {
-					reply = JSON.parse(String(data));
-				} catch {
-					return fail("the reply was not a hello result");
-				}
-				if (isJsonObject(reply) && isJsonObject(reply.error)) return fail(String(reply.error.message), TURNED_AWAY.has(String(reply.error.code)), String(reply.error.code));
-				const capabilities = isJsonObject(reply) && isJsonObject(reply.result) ? reply.result.capabilities : null;
-				if (!Array.isArray(capabilities) || !capabilities.includes(capability)) return fail(`it has not granted this Mac ${capability === "build" ? "build" : "hosting"} access`, true, "forbidden");
-				const features = isJsonObject(reply) && isJsonObject(reply.result) ? reply.result.features : null;
-				resolve(new BuildConnection(socket, Array.isArray(features) ? features.filter((each) => typeof each === "string") : []));
-			});
-		});
-	}
-	supports(feature) {
-		return this.features.includes(feature);
-	}
-	request(method, params, timeoutMs = REQUEST_TIMEOUT_MS) {
-		if (this.closed) return Promise.resolve({ error: {
-			code: "closed",
-			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(done({ error: {
-					code: "timeout",
-					message: `${method} got no reply in ${timeoutMs / 1e3} s`
-				} }));
-			}, timeoutMs);
-			this.pending.set(id, (reply) => {
-				clearTimeout(timer);
-				resolve(done(reply));
-			});
-			this.socket.send(JSON.stringify({
-				id,
-				method,
-				params
-			}));
-		});
-	}
-	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));
-	}
-	onProgress(listener) {
-		this.progress = listener;
-	}
-	onBinary(listener) {
-		this.binary = listener;
-	}
-	get failure() {
-		return this.closed;
-	}
-	/**
-	* Treats `SILENT_MS` without a frame as a dropped connection from now on. Only while waiting on a job: a long
-	* upload or this process hashing the checkout can delay pongs without anything being wrong.
-	*/
-	watch() {
-		this.heard = Date.now();
-		this.watched = true;
-	}
-	/** Closes with a close frame, which tells the machine to cancel this connection's jobs. */
-	close() {
-		if (this.ended) return;
-		this.forget();
-		if (this.socket.readyState === WebSocket.CLOSED) return;
-		const timer = setTimeout(() => this.socket.terminate(), CLOSE_TIMEOUT_MS);
-		this.socket.once("close", () => clearTimeout(timer));
-		this.socket.close(1e3);
-	}
-	/** Ends the connection without a close frame, which leaves its jobs on the machine for a new connection. */
-	drop() {
-		if (this.ended) return;
-		this.forget();
-		this.socket.terminate();
-	}
-	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);
-	}
-};
-function replyError(reply) {
-	return "error" in reply ? `${reply.error.code}: ${reply.error.message}` : null;
-}
-/** The repository on the remote Mac: one area per git common dir, shared by all its worktrees. */
-function repoIdentity(projectRoot) {
-	const repoRoot = realpathSync(git(projectRoot, ["rev-parse", "--show-toplevel"]));
-	const common = realpathSync(git(repoRoot, [
-		"rev-parse",
-		"--path-format=absolute",
-		"--git-common-dir"
-	]));
-	const digest = createHash("sha256").update(common).digest("hex").slice(0, 12);
-	const name = (basename(dirname(common)) || "repo").replace(/[^A-Za-z0-9._-]/g, "_").replace(/^[^A-Za-z0-9]+/, "");
-	const lock = [
-		"pnpm-lock.yaml",
-		"yarn.lock",
-		"package-lock.json"
-	].find((file) => existsSync(join(repoRoot, file)));
-	return {
-		repoRoot,
-		project: relative(repoRoot, realpathSync(projectRoot)),
-		repo: `${name.slice(0, 60) || "repo"}-${digest}`,
-		lockfile: lock ? createHash("sha256").update(readFileSync(join(repoRoot, lock))).digest("hex") : null
-	};
-}
-const sha256 = (content) => createHash("sha256").update(content).digest("hex");
-/** Why the native inputs cannot be sent to a remote Mac, such as an ignored file among them, or null when they can. */
-function nativeTransferRefusal(repoRoot, snapshot) {
-	try {
-		checkNativeTransferMembership(snapshot, gitVisiblePaths(repoRoot));
-		return null;
-	} catch (error) {
-		return error.message.split("\n")[0];
-	}
-}
-function blobContent(repoRoot, file) {
-	const absolute = join(repoRoot, file.path);
-	return file.kind === "directory" ? Buffer.alloc(0) : file.kind === "link" ? Buffer.from(readlinkSync(absolute)) : readFileSync(absolute);
-}
-/** Closes every connection the choice still holds. */
-function closeOffload(choice) {
-	choice.connection.close();
-	for (const each of choice.runnersUp.splice(0)) each.connection.close();
-}
-const NATIVE_BUILD_FEATURE = {
-	xcode: "native-xcode-build",
-	gradle: "native-gradle-build"
-};
-const unsupportedNative = (provider) => `This worker does not support native ${provider === "xcode" ? "Xcode" : "Gradle"} builds.`;
-const ANDROID_PACKAGE = /^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+$/;
-function nativeTransferInput(native) {
-	return native?.provider === "xcode" ? native.snapshot : native?.transfer;
-}
-/** Connects to one paired machine and asks it for an offer; the caller closes the connection it returns. */
-async function probeMachine(credential, identity, { connectMs = CONNECT_TIMEOUT_MS, offerMs = OFFER_TIMEOUT_MS } = {}) {
-	const target = await pinnedEndpoint$1(credential);
-	if (typeof target === "string") return {
-		credential,
-		failure: target
-	};
-	const connection = await BuildConnection.open(target, credential.deviceToken, connectMs);
-	if (!(connection instanceof BuildConnection)) return {
-		credential,
-		failure: connection.failure
-	};
-	if (identity.native && !connection.supports(NATIVE_BUILD_FEATURE[identity.native])) {
-		connection.close();
-		return {
-			credential,
-			failure: unsupportedNative(identity.native)
-		};
-	}
-	const native = identity.native === "gradle" || identity.native && connection.supports("native-xcode-toolchain") ? identity.native : void 0;
-	const reply = await connection.request("build.offer", {
-		repo: identity.repo,
-		...identity.lockfile ? { lockfile: identity.lockfile } : {},
-		...native ? { native } : identity.rubyVersion ? { rubyVersion: identity.rubyVersion } : {}
-	}, offerMs);
-	const failure = replyError(reply);
-	if (failure || !("result" in reply)) {
-		connection.close();
-		return {
-			credential,
-			failure: failure ?? "no offer"
-		};
-	}
-	return {
-		credential,
-		connection,
-		offer: reply.result
-	};
-}
-/**
-* 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", onCandidates }) {
-	const started = Date.now();
-	let identity;
-	try {
-		identity = repoIdentity(projectRoot);
-	} catch (error) {
-		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);
-	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,
-		...target.platform !== "macos" ? { native: target.native } : {}
-	})));
-	const { order, reasons, candidates } = pickOffer({
-		localEnabled: selected !== "auto" || automaticMachineEnabled("build", "local"),
-		selected,
-		mode,
-		here,
-		target,
-		offers: asked.map((each) => ({
-			machine: each.credential.machine,
-			offer: "offer" in each ? each.offer : null,
-			..."failure" in each ? { failure: each.failure } : {}
-		}))
-	});
-	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) => {
-		const pick = asked[at];
-		return {
-			machine: pick.credential.machine,
-			credential: pick.credential,
-			connection: pick.connection,
-			offer: pick.offer
-		};
-	});
-	return {
-		...first,
-		target,
-		offerMs: Date.now() - started,
-		identity,
-		runnersUp: rest,
-		automatic: selected === "auto"
-	};
-}
-function validArtifactIdentity(request, fingerprint) {
-	if (request.platform === "macos") return true;
-	return request.native?.provider === "gradle" ? fingerprint === null : typeof fingerprint === "string" && fingerprint.length > 0;
-}
-const ARTIFACT_NAME = {
-	ios: /^[^/]+\.app$/,
-	android: /^[^/]+\.apk$/,
-	macos: /^[^/]+\.app$/
-};
-/**
-* Reconnects to the machine that runs `job` and takes the job over with `build.attach`, retrying until
-* `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, signal, native) {
-	const deadline = Date.now() + RESUME_WINDOW_MS;
-	let delay = RESUME_DELAY_MS;
-	let last = "no attempt";
-	while (!abandoned()) {
-		const target = await pinnedEndpoint$1(credential);
-		const connection = typeof target === "string" ? {
-			failure: target,
-			refused: false
-		} : await BuildConnection.open(target, credential.deviceToken, CONNECT_TIMEOUT_MS);
-		if (!(connection instanceof BuildConnection)) {
-			if (connection.refused) return `the machine turned this Mac away (${connection.failure})`;
-			last = connection.failure;
-		} else {
-			if (abandoned()) {
-				connection.close();
-				break;
-			}
-			if (native && !connection.supports(NATIVE_BUILD_FEATURE[native])) {
-				connection.close();
-				return unsupportedNative(native);
-			}
-			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 {
-					connection,
-					outcome: isJsonObject(outcome) ? outcome : null,
-					early
-				};
-			}
-			last = replyError(reply);
-			if (reply.error.code !== "closed" && reply.error.code !== "timeout") {
-				connection.close();
-				return `the machine did not hand the build back (${last})`;
-			}
-			connection.drop();
-		}
-		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})`;
-}
-/** Mirrors the checkout on the machine: the manifest in pages, then every blob it lacks. */
-async function syncSource(connection, identity, onEnter, native) {
-	onEnter("sync");
-	const syncStarted = Date.now();
-	const manifest = native && "declaration" in native ? nativeGradleTransfer(join(identity.repoRoot, identity.project), native.declaration).files : native ? nativeTransferManifest(identity.repoRoot, native, sourceManifest(identity.repoRoot)) : sourceManifest(identity.repoRoot);
-	if (native && "declaration" in native && manifestDigest(manifest) !== native.digest) return { failure: "The native Gradle source changed before upload." };
-	const bySha = new Map(manifest.map((file) => [file.sha256, file]));
-	const missing = [];
-	for (let index = 0; index < manifest.length || index === 0;) {
-		const page = [];
-		let bytes = 0;
-		while (index < manifest.length && (page.length === 0 || bytes < PAGE_BYTES)) {
-			const file = manifest[index++];
-			bytes += Buffer.byteLength(JSON.stringify(file)) + 1;
-			page.push(file);
-		}
-		const done = index >= manifest.length;
-		const reply = await connection.request("build.sync", {
-			repo: identity.repo,
-			files: page,
-			done
-		});
-		const failure = replyError(reply);
-		if (failure || !("result" in reply)) return { failure: `sync: ${failure ?? "no reply"}` };
-		missing.push(...reply.result.missing ?? []);
-		if (done) break;
-	}
-	let uploadedBytes = 0;
-	for (const digest of missing) {
-		const file = bySha.get(digest);
-		if (!file) return { failure: `sync: the machine asked for an unknown blob ${digest}` };
-		const content = blobContent(identity.repoRoot, file);
-		if (sha256(content) !== digest) return { failure: `sync: ${file.path} changed while syncing` };
-		const header = Buffer.from(digest, "hex");
-		for (let offset = 0; offset < content.length || offset === 0; offset += CHUNK_BYTES) {
-			await connection.sendBinary(Buffer.concat([header, content.subarray(offset, offset + CHUNK_BYTES)]));
-			if (content.length === 0) break;
-		}
-		uploadedBytes += content.length;
-		if (connection.failure) return { failure: `sync: ${connection.failure}` };
-	}
-	return {
-		files: manifest.length,
-		uploaded: missing.length,
-		uploadedBytes,
-		syncMs: Date.now() - syncStarted,
-		digest: manifestDigest(manifest)
-	};
-}
-function stagedArtifactEscapes(stagingDir, artifactPath, hasContents) {
-	if ((hasContents ? [artifactPath, join(artifactPath, "Contents")] : [artifactPath]).some((path) => lstatSync(path, { throwIfNoEntry: false })?.isSymbolicLink())) return true;
-	if (!existsSync(artifactPath)) return false;
-	const inside = relative(realpathSync(stagingDir), realpathSync(artifactPath));
-	return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
-}
-/**
-* Builds on the chosen machine and brings the `.app` or `.apk` back into `stagingDir`, verified against the
-* sha256 the machine reports. The caller re-fingerprints and stores it.
-*/
-async function offloadBuild({ choice, expectedFingerprint, request, stagingDir, onPhase, onEnter, onRecord, note }) {
-	const { identity } = choice;
-	const native = request.platform !== "macos" ? request.native : void 0;
-	let sourceDigest = null;
-	const started = Date.now();
-	const fail = (reason) => {
-		closeOffload(choice);
-		return {
-			ok: false,
-			machine: choice.machine,
-			reason: reason.split("\n")[0].slice(0, 300)
-		};
-	};
-	const signal = runCancellationSignal();
-	const checkCancelled = () => throwIfCancelled(signal, "offloaded build");
-	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 {
-		checkCancelled();
-		if (!validArtifactIdentity(request, expectedFingerprint)) return fail("The build request has an invalid reusable artifact identity.");
-		if (native?.provider === "xcode" && native.snapshot.hash !== expectedFingerprint) return fail("The native source snapshot does not match the requested artifact identity.");
-		let job = null;
-		let early = [];
-		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, signal, native?.provider);
-			resuming = false;
-			if (settled) {
-				if (typeof resumed !== "string") resumed.connection.close();
-				return;
-			}
-			if (typeof resumed === "string") return settle({
-				ok: false,
-				code: "closed",
-				message: `${why}; ${resumed}`
-			});
-			choice.connection = resumed.connection;
-			resumed.connection.watch();
-			note(`offload: reattached to the build on ${choice.machine}`);
-			resumed.connection.onProgress(handle);
-			if (resumed.outcome) settle(resumed.outcome);
-			for (const event of resumed.early.splice(0)) handle(event);
-		};
-		const handle = (event) => {
-			if (event.job && event.job !== job) return;
-			if (event.outcome?.code === "dropped" && !event.job && job !== null) {
-				reattach(String(event.outcome.message));
-				return;
-			}
-			if (event.outcome) return settle(event.outcome);
-			if (event.record) onRecord(event.record);
-			if (event.phase && typeof event.msg === "string") {
-				onEnter(event.phase);
-				onPhase(event.phase, event.msg);
-			}
-		};
-		let syncMs = 0;
-		let uploadedBytes = 0;
-		let workerStarted = 0;
-		const moveOn = (why) => {
-			const next = choice.runnersUp.shift();
-			if (!next) return false;
-			note(`placement: ${next.machine} (${choice.machine} could not take the build: ${why})`);
-			choice.connection.close();
-			Object.assign(choice, next);
-			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);
-			}
-			if (native && !choice.connection.supports(NATIVE_BUILD_FEATURE[native.provider])) {
-				const reason = unsupportedNative(native.provider);
-				if (moveOn(reason)) continue;
-				return fail(reason);
-			}
-			const synced = await syncSource(choice.connection, identity, onEnter, nativeTransferInput(native));
-			checkCancelled();
-			if ("failure" in synced) {
-				if (moveOn(synced.failure)) continue;
-				return fail(synced.failure);
-			}
-			({syncMs, uploadedBytes} = synced);
-			sourceDigest = synced.digest;
-			onPhase("sync", `${synced.files} files, uploaded ${synced.uploaded} (${mb(uploadedBytes)}) in ${seconds(syncMs)}`);
-			workerStarted = Date.now();
-			early = [];
-			choice.connection.onProgress((event) => job === null ? early.push(event) : handle(event));
-			if (choice.automatic) requireAutomaticMachine("build", choice.machine);
-			checkCancelled();
-			const reply = await choice.connection.request("build.start", {
-				repo: identity.repo,
-				project: identity.project,
-				platform: request.platform,
-				fingerprint: request.platform === "macos" ? synced.digest : expectedFingerprint,
-				...native ? { native: {
-					provider: native.provider,
-					sourceDigest: synced.digest,
-					...native.provider === "xcode" ? {
-						cacheKey: native.cacheKey,
-						arch: native.arch,
-						parameters: native.snapshot.parameters
-					} : { inputs: native.transfer.declaration }
-				} } : {},
-				...request.platform === "macos" ? { macos: {
-					product: request.product,
-					infoPlist: request.infoPlist,
-					bundleId: request.bundleId,
-					...request.resources !== void 0 ? { resources: request.resources } : {},
-					...request.assetCatalog !== void 0 ? { assetCatalog: request.assetCatalog } : {}
-				} } : {
-					configuration: request.platform === "ios" ? request.configuration : null,
-					scheme: request.platform === "ios" ? request.scheme : null,
-					iosProjectPath: request.platform === "ios" ? request.iosProjectPath ?? null : null,
-					runtime: request.platform === "ios" ? request.runtime : null,
-					packageName: packageName(join(identity.repoRoot, identity.project)),
-					isExpo: request.isExpo,
-					optimizations: request.platform === "ios" && isJsonObject(request.optimizations) ? request.optimizations : null,
-					...request.platform === "android" ? { android: request.android } : {}
-				},
-				stimBuild: choice.target.local.stimBuild
-			});
-			checkCancelled();
-			if ("result" in reply) {
-				job = reply.result.job;
-				break;
-			}
-			const refused = `start: ${replyError(reply)}`;
-			if (reply.error.code === "bad-request" || !moveOn(refused)) return fail(refused);
-		}
-		for (const each of choice.runnersUp.splice(0)) each.connection.close();
-		choice.connection.watch();
-		for (const event of early.splice(0)) handle(event);
-		const timer = setTimeout(() => settle({
-			ok: false,
-			code: "timeout",
-			message: "the build did not finish in time"
-		}), JOB_TIMEOUT_MS);
-		const result = await outcome;
-		clearTimeout(timer);
-		checkCancelled();
-		const { connection, machine } = choice;
-		connection.onProgress(null);
-		const workerMs = Date.now() - workerStarted;
-		if (result.ok !== true) return fail(`${String(result.code ?? "failed")}: ${String(result.message ?? "")}`);
-		if (native && (result.sourceDigest !== sourceDigest || result.fingerprint !== expectedFingerprint)) return fail("The worker returned a different native source or artifact identity.");
-		if (native?.provider === "gradle" && !ANDROID_PACKAGE.test(String(result.androidPackage ?? ""))) return fail("The worker returned no verified native APK package.");
-		const artifact = result.artifact;
-		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");
-		checkCancelled();
-		const fetchStarted = Date.now();
-		rmSync(stagingDir, {
-			recursive: true,
-			force: true
-		});
-		mkdirSync(stagingDir, { recursive: true });
-		const archive = join(stagingDir, "app.tgz");
-		const fd = openSync(archive, "w");
-		const hash = createHash("sha256");
-		let received = 0;
-		let badFrame = false;
-		connection.onBinary((frame) => {
-			if (frame.length < DIGEST_BYTES || frame.subarray(0, DIGEST_BYTES).toString("hex") !== artifact.sha256) {
-				badFrame = true;
-				return;
-			}
-			const data = frame.subarray(DIGEST_BYTES);
-			try {
-				writeSync(fd, data);
-			} catch {
-				badFrame = true;
-				return;
-			}
-			hash.update(data);
-			received += data.length;
-		});
-		const fetched = await connection.request("build.artifact", { job }, 9e5);
-		connection.onBinary(null);
-		closeSync(fd);
-		checkCancelled();
-		const fetchFailure = replyError(fetched);
-		if (fetchFailure || !("result" in fetched)) return fail(`fetch: ${fetchFailure ?? "no reply"}`);
-		const digest = hash.digest("hex");
-		const declared = fetched.result;
-		if (badFrame) return fail("fetch: an artifact frame had another digest or could not be written here");
-		if (digest !== artifact.sha256 || declared.sha256 !== digest || declared.size !== received) return fail(`fetch: the artifact's sha256 ${digest.slice(0, 12)} does not match ${String(artifact.sha256).slice(0, 12)}`);
-		await getExecutor().runFileAsync("tar", [
-			"-xf",
-			archive,
-			"-C",
-			stagingDir
-		], { timeoutMs: 6e5 });
-		checkCancelled();
-		rmSync(archive, { force: true });
-		const artifactPath = join(stagingDir, name);
-		if (stagedArtifactEscapes(stagingDir, artifactPath, request.platform === "macos")) return fail(`fetch: ${machine} returned ${name} as or through a symbolic link or outside the staging directory`);
-		if (request.platform === "ios" && !existsSync(join(artifactPath, "Info.plist"))) return fail(`fetch: ${name} has no Info.plist`);
-		if (request.platform === "android" && !(lstatSync(artifactPath, { throwIfNoEntry: false })?.isFile() ?? false)) return fail(`fetch: ${name} is not a file`);
-		if (request.platform === "macos") {
-			for (const segments of [["Contents", "Info.plist"], [
-				"Contents",
-				"MacOS",
-				request.product
-			]]) if (!lstatSync(join(artifactPath, ...segments), { throwIfNoEntry: false })?.isFile()) return fail(`fetch: ${name} has no regular ${segments.join("/")}`);
-		}
-		const fetchMs = Date.now() - fetchStarted;
-		connection.close();
-		return {
-			ok: true,
-			machine,
-			artifactPath,
-			...typeof declared.handoff === "string" && /^[0-9a-f]{64}$/.test(declared.handoff) ? { handoff: {
-				nodeId: choice.credential.nodeId,
-				token: declared.handoff,
-				sha256: digest
-			} } : {},
-			compilationCache: request.platform === "ios" ? compilationActivity(result.compilationCache) : COMPILATION_CACHE_UNAVAILABLE,
-			...native?.provider === "gradle" ? { androidPackage: result.androidPackage } : {},
-			ccache: request.platform === "android" ? ccacheActivity(result.compilationCache) : CCACHE_UNAVAILABLE,
-			timings: {
-				offerMs: choice.offerMs,
-				syncMs,
-				workerMs,
-				fetchMs,
-				totalMs: Date.now() - started + choice.offerMs,
-				worker: isJsonObject(result.timings) ? result.timings : {},
-				uploadedBytes,
-				artifactBytes: received
-			}
-		};
-	} catch (error) {
-		closeOffload(choice);
-		checkCancelled();
-		return fail(error.message.split("\n")[0] ?? String(error));
-	} finally {
-		signal?.removeEventListener("abort", cancel);
-	}
-}
-function packageName(projectRoot) {
-	try {
-		const name = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8")).name;
-		return typeof name === "string" ? name : null;
-	} catch {
-		return null;
-	}
-}
-const numberOrNull = (field) => typeof field === "number" ? field : null;
-function compilationActivity(value) {
-	if (!isJsonObject(value) || value.status !== "reported") return COMPILATION_CACHE_UNAVAILABLE;
-	return {
-		status: "reported",
-		hits: numberOrNull(value.hits),
-		cacheableTasks: numberOrNull(value.cacheableTasks),
-		hitRatePercent: numberOrNull(value.hitRatePercent)
-	};
-}
-function ccacheActivity(value) {
-	if (!isJsonObject(value) || value.status !== "reported") return CCACHE_UNAVAILABLE;
-	return {
-		status: "reported",
-		hits: numberOrNull(value.hits),
-		misses: numberOrNull(value.misses),
-		hitRatePercent: numberOrNull(value.hitRatePercent)
-	};
-}
-const mb = (bytes) => `${(bytes / 1024 ** 2).toFixed(1)} MB`;
-const seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
-function simulatorRuntime(udid) {
-	try {
-		const listed = JSON.parse(getExecutor().runFileQuiet("xcrun", [
-			"simctl",
-			"list",
-			"devices",
-			"-j"
-		], { timeoutMs: 2e4 }) ?? "{}");
-		for (const [runtime, devices] of Object.entries(listed.devices ?? {})) if (devices.some((device) => device.udid === udid)) return runtime;
-	} catch {}
-	return null;
-}
-const DOCTOR_CONNECT_MS = 5e3;
-const DOCTOR_OFFER_MS = 8e3;
-const PLATFORM_LABEL = {
-	ios: "iOS",
-	android: "Android",
-	macos: "macOS"
-};
-const SHARED_PROBLEMS = /* @__PURE__ */ new Set([
-	"stim-build",
-	"arch",
-	"disk",
-	"busy"
-]);
-/**
-* Doctor's offload check for `projectRoot`: one bounded offer per machine, judged for each build `targets` returns
-* by `offerProblems` exactly as placement judges it. No build runs. With several targets, a problem that only
-* one platform has names it.
-*/
-function offloadCheck(projectRoot, targets) {
-	let identity;
-	try {
-		identity = repoIdentity(projectRoot);
-	} catch (error) {
-		identity = error.message.split("\n")[0] ?? "git failed";
-	}
-	let resolved = null;
-	return async (credential) => {
-		if (typeof identity === "string") return {
-			capacity: null,
-			problems: [{
-				code: "checkout",
-				reason: `this app is not in a git checkout (${identity})`
-			}]
-		};
-		const probe = await probeMachine(credential, {
-			...identity,
-			rubyVersion: readRubyVersion(projectRoot) ?? void 0
-		}, {
-			connectMs: DOCTOR_CONNECT_MS,
-			offerMs: DOCTOR_OFFER_MS
-		});
-		if ("failure" in probe) return {
-			capacity: null,
-			problems: [{
-				code: "unreachable",
-				reason: probe.failure
-			}]
-		};
-		probe.connection.close();
-		resolved ??= targets();
-		const resolvedTargets = await resolved;
-		const problems = [];
-		for (const target of resolvedTargets) for (const problem of offerProblems(probe.offer, target)) {
-			const labeled = resolvedTargets.length > 1 && !SHARED_PROBLEMS.has(problem.code) ? {
-				...problem,
-				reason: `${PLATFORM_LABEL[target.platform]}: ${problem.reason}`
-			} : problem;
-			if (!problems.some((each) => each.code === labeled.code && each.reason === labeled.reason)) problems.push(labeled);
-		}
-		return {
-			capacity: probe.offer.capacity,
-			problems
-		};
-	};
-}
-//#endregion
-export { inspectDeviceHostMachines as C, hostingMachines as S, requireLocalBuild as _, nativeTransferRefusal as a, inspectBuildMachines as b, offloadPlacement as c, simulatorRuntime as d, setRemoteLogSink as f, parseBuildMachineOption as g, namedBuildMachine as h, closeOffload as i, placementLoad as l, buildPlacementSettings as m, buildPlacementCandidates as n, offloadBuild as o, OffloadRefusal as p, chooseBuildMachine as r, offloadCheck as s, BuildConnection as t, remotePhaseText as u, resolveBuildMachine as v, configuredMachines as x, resolveBuildPlacement as y };