stim 1.16.0 → 1.17.0

package/dist/ios-state-8L3lgum6.mjs

@@ -0,0 +1,89 @@
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-DqcCbpE7.mjs";
+import { HOSTED_METRO_REQUESTS_KEY, hostedMetroRequests, hostedNativeRecords, isJsonObject, parseHostedNativePlacement, unreadableHostedNative } from "@stim-cli/core/state";
+//#region src/device-host/ios-state.ts
+function readHostedNative(root, platform, slot) {
+	const state = readWorkspaceState$1(root);
+	if (slot !== void 0) {
+		const record = hostedNativeRecords(state, platform)[slot];
+		if (record !== void 0 && !parseHostedNativePlacement(record, platform)) throw Object.assign(new Error(unreadableHostedNative(slot, platform)), {
+			code: "STIM_HOSTING_REFUSED",
+			remedy: `Restore that slot's recorded machine and session from the host, then run stim stop${slot === "default" ? "" : ` --slot ${slot}`} to reconcile it.`
+		});
+	}
+	const placements = Object.fromEntries(Object.entries(hostedNativeRecords(state, platform)).flatMap(([name, record]) => {
+		const placement = parseHostedNativePlacement(record, platform);
+		return placement ? [[name, placement]] : [];
+	}));
+	return slot === void 0 ? placements : placements[slot] ? { [slot]: placements[slot] } : {};
+}
+function writeDevicePlacement(root, slot, platform, placement) {
+	if (!placement) return;
+	updateWorkspaceState(root, (state) => {
+		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
+		const saved = isJsonObject(slots[slot]) ? slots[slot] : {};
+		const current = slot === "default" ? state[platform] : saved[platform];
+		const record = {
+			...isJsonObject(current) ? current : {},
+			devicePlacement: placement
+		};
+		if (slot === "default") return {
+			...state,
+			[platform]: record
+		};
+		return {
+			...state,
+			deviceSlots: {
+				...slots,
+				[slot]: {
+					...saved,
+					[platform]: record
+				}
+			}
+		};
+	});
+}
+function writeHostedNative(root, slot, host, platform) {
+	updateWorkspaceState(root, (state) => {
+		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
+		const current = slot === "default" ? state[platform] : isJsonObject(slots[slot]) ? slots[slot][platform] : void 0;
+		const record = isJsonObject(current) ? { ...current } : {};
+		const previous = parseHostedNativePlacement(record.host, platform);
+		if (previous && previous.session !== host?.session) {
+			const requests = { ...hostedMetroRequests(state) };
+			delete requests[previous.session];
+			state = {
+				...state,
+				[HOSTED_METRO_REQUESTS_KEY]: requests
+			};
+		}
+		if (host) record.host = host;
+		else delete record.host;
+		return slot === "default" ? {
+			...state,
+			[platform]: record
+		} : {
+			...state,
+			deviceSlots: {
+				...slots,
+				[slot]: {
+					...isJsonObject(slots[slot]) ? slots[slot] : {},
+					[platform]: record
+				}
+			}
+		};
+	});
+}
+function readHostedIos(root, slot) {
+	return readHostedNative(root, "ios", slot);
+}
+function writeHostedIos(root, slot, host) {
+	writeHostedNative(root, slot, host, "ios");
+}
+function readHostedAndroid(root, slot) {
+	return readHostedNative(root, "android", slot);
+}
+function writeHostedAndroid(root, slot, host) {
+	writeHostedNative(root, slot, host, "android");
+}
+//#endregion
+export { writeHostedAndroid as a, writeDevicePlacement as i, readHostedIos as n, writeHostedIos as o, readHostedNative as r, writeHostedNative as s, readHostedAndroid as t };

package/dist/{launch-verify-2DBRizjo.mjs → launch-verify-lTnWZikR.mjs}

@@ -1,8 +1,8 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { s as isAppLaunchError } from "./command-output-DnJMdEY-.mjs";
+import { s as isAppLaunchError } from "./command-output-CDAIFD-8.mjs";
 import { o as readNdjsonGenerations } from "./ndjson-PclOIwVY.mjs";
 import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Ee7sDXfp.mjs";
-import { f as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, s as androidAppProcess } from "./app-install-CKWdbXIX.mjs";
+import { f as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, s as androidAppProcess } from "./app-install-VPkI5WEg.mjs";
 import { join } from "node:path";
 //#region src/engine/app-readiness.ts
 const APP_READINESS_TIMEOUT_MS = 3e4;

package/dist/{logs-CHEVK8zD.mjs → logs-DUoKlDoS.mjs}

@@ -1,15 +1,15 @@
 import { H as projectDeviceSlots, V as parseDeviceSlotOption, _ as loadConfig$1, g as isPathPrefix } from "./config-D0DbpZtM.mjs";
 import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { f as refuseNoProject, l as phaseLine, v as launchErrorPreview } from "./command-output-DnJMdEY-.mjs";
-import { a as findCommandWorkspace } from "./project-Du91Ilvc.mjs";
-import { r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
-import { n as agentDeviceLiveness, u as readAgentDeviceRecords } from "./activity-BxwdD81S.mjs";
+import { f as refuseNoProject, l as phaseLine, v as launchErrorPreview } from "./command-output-CDAIFD-8.mjs";
+import { o as findCommandWorkspace } from "./project-D47Rh0ly.mjs";
+import { r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
+import { n as agentDeviceLiveness, u as readAgentDeviceRecords } from "./activity-IRvJY_ru.mjs";
 import { n as SOURCES, t as LEVELS } from "./ndjson-PclOIwVY.mjs";
-import { o as connectHost } from "./hosted-client-a-WmqE2L.mjs";
-import { n as pullHostedMacosLogs, t as pullHostedIosLogs } from "./hosted-logs-D5g041Q3.mjs";
-import "./hosted-macos-BSZyIb3y.mjs";
-import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-B9L4Ae0x.mjs";
-import { t as readHostedIos } from "./ios-state-DS5UpYTH.mjs";
+import { o as connectHost } from "./hosted-client-wk1W_CNW.mjs";
+import { n as pullHostedNativeLogs, t as pullHostedMacosLogs } from "./hosted-logs-DqYmWtXc.mjs";
+import "./hosted-macos-dlHXEeF5.mjs";
+import { n as readHostedIos, t as readHostedAndroid } from "./ios-state-8L3lgum6.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-C-NMnhrk.mjs";
 import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
 import { realpathSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
@@ -17,8 +17,15 @@ import { agentDeviceStateDirs, buildCriteria, compileGrep, createAgentActionRead
 import { homedir } from "node:os";
 import chalk from "chalk";
 //#region src/devices/agent-actions.ts
-function workspaceAgentTargets(project) {
+function workspaceAgentTargets(project, macos) {
 	const targets = [];
+	if (macos?.app && macos.bundleId) targets.push({
+		platform: "macos",
+		id: macos.launchId,
+		slot: "default",
+		bundleId: macos.bundleId,
+		launchedAt: macos.app.startedAtMicros / 1e3
+	});
 	let slots;
 	try {
 		slots = projectDeviceSlots(project);
@@ -49,7 +56,6 @@ function canonicalDir(path) {
 	}
 }
 function createAgentActionReader$1({ targets, sinceTs, home = homedir(), now, startOf = process_identity_exports.inspectProcessStart }) {
-	const byId = new Map(targets.map((target) => [target.id, target]));
 	let claimed;
 	const read = createAgentActionReader({
 		sessionsDirs: () => agentDeviceStateDirs(home).map((root) => join(root, "sessions")),
@@ -57,9 +63,10 @@ function createAgentActionReader$1({ targets, sinceTs, home = homedir(), now, st
 		sinceTs,
 		now,
 		claimedDevice: (session, sessionsDir) => {
+			const byId = claimed ? /* @__PURE__ */ new Map() : new Map((typeof targets === "function" ? targets() : targets).map((target) => [target.id, target]));
 			claimed ??= new Map(readAgentDeviceRecords(home).filter((record) => record.kind === "claim" && record.session && record.deviceId).filter((record) => {
 				const target = byId.get(record.deviceId);
-				return target?.name === void 0 || target.name === record.deviceName;
+				return target?.platform !== "macos" && (target?.name === void 0 || target.name === record.deviceName);
 			}).filter((record) => agentDeviceLiveness(record, startOf) === "live").map((record) => [`${record.stateDir ? canonicalDir(record.stateDir) : ""}\0${record.session}`, record.deviceId]));
 			return claimed.get(`${canonicalDir(dirname(sessionsDir))}\0${session}`) ?? claimed.get(`\0${session}`) ?? null;
 		}
@@ -76,11 +83,11 @@ function warning(machine, error) {
 	const hint = message.includes("refused device-host.logs.query") ? ` If ${machine} runs an older stim-server, update it.` : "";
 	return phaseLine("device", `Could not read the app's logs from ${machine}: ${message}. Showing the logs already copied here.${hint}`);
 }
-async function syncHostedMacosLogs(root, placement, slot, warnings) {
+async function syncHostedMacosLogs(root, placement, slot, warnings, platform = "ios") {
 	let host;
 	try {
 		host = await connectHost(placement.machine);
-		if (slot !== void 0) await pullHostedIosLogs(root, slot, placement, host);
+		if (slot !== void 0) await pullHostedNativeLogs(root, slot, placement, host, false, platform);
 		else await pullHostedMacosLogs(root, placement, host);
 		return true;
 	} catch (error) {
@@ -93,7 +100,7 @@ async function syncHostedMacosLogs(root, placement, slot, warnings) {
 		host?.connection.close();
 	}
 }
-function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3, slot } = {}) {
+function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3, slot, platform = "ios" } = {}) {
 	let host;
 	let retryAt = 0;
 	let stopped = false;
@@ -102,20 +109,20 @@ function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryM
 		if (running || stopped || Date.now() < retryAt) return;
 		running = true;
 		try {
-			const placement = slot !== void 0 ? readHostedIos(root)[slot] : readMacosRecord(root)?.host;
+			const placement = slot !== void 0 ? (platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))[slot] : readMacosRecord(root)?.host;
 			if (!placement) {
 				host?.connection.close();
 				host = void 0;
 				return;
 			}
 			host ??= await connectHost(placement.machine);
-			if (slot !== void 0) await pullHostedIosLogs(root, slot, placement, host);
+			if (slot !== void 0) await pullHostedNativeLogs(root, slot, placement, host, false, platform);
 			else await pullHostedMacosLogs(root, placement, host);
 			failing = false;
 		} catch (error) {
 			host?.connection.close();
 			host = void 0;
-			if (!failing) process.stderr.write(`${warning((slot !== void 0 ? readHostedIos(root)[slot] : readMacosRecord(root)?.host)?.machine ?? "the host", error)}\n`);
+			if (!failing) process.stderr.write(`${warning((slot !== void 0 ? (platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))[slot] : readMacosRecord(root)?.host)?.machine ?? "the host", error)}\n`);
 			failing = true;
 			retryAt = Date.now() + retryMs;
 		} finally {
@@ -132,17 +139,22 @@ function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryM
 async function syncHostedLogs(root) {
 	const macos = readMacosRecord(root)?.host;
 	const warnings = /* @__PURE__ */ new Set();
-	return (await Promise.all([...macos ? [syncHostedMacosLogs(root, macos)] : [], ...Object.entries(readHostedIos(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings))])).every(Boolean);
+	return (await Promise.all([
+		...macos ? [syncHostedMacosLogs(root, macos)] : [],
+		...Object.entries(readHostedIos(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings)),
+		...Object.entries(readHostedAndroid(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings, "android"))
+	])).every(Boolean);
 }
 function followHostedLogs(root, failing) {
 	const stops = /* @__PURE__ */ new Map();
 	const refresh = () => {
 		if (readMacosRecord(root)?.host && !stops.has("macos")) stops.set("macos", followHostedMacosLogs(root, { failing }));
-		for (const slot of Object.keys(readHostedIos(root))) {
-			const key = `ios:${slot}`;
+		for (const platform of ["ios", "android"]) for (const slot of Object.keys(platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))) {
+			const key = `${platform}:${slot}`;
 			if (!stops.has(key)) stops.set(key, followHostedMacosLogs(root, {
 				failing,
-				slot
+				slot,
+				platform
 			}));
 		}
 	};
@@ -301,8 +313,9 @@ function logsCommand(program) {
 		const offsets = opts.follow ? fileSizes(dir) : null;
 		const workspaceTimeline = opts.follow ? readLogRecords(dir) : captured;
 		const agentSince = workspaceTimeline[0]?.ts ?? (opts.follow ? Date.now() : void 0);
+		const project = loadConfig$1()?.projects?.[root];
 		const readAgent = (sources ? sources.includes("agent") : !opts.errors) && agentSince !== void 0 ? createAgentActionReader$1({
-			targets: workspaceAgentTargets(loadConfig$1()?.projects?.[root]),
+			targets: () => workspaceAgentTargets(project, readMacosRecord(root)),
 			sinceTs: agentSince
 		}) : null;
 		const timeline = readAgent ? sortByTs([...workspaceTimeline, ...readAgent()]) : workspaceTimeline;

package/dist/{client-BTY686R6.mjs → machines-C2XiNwh9.mjs}

@@ -1,12 +1,13 @@
 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-B8-aJ1_5.mjs";
-import { T as CCACHE_UNAVAILABLE, a as toolchainMismatches, l as COMPILATION_CACHE_UNAVAILABLE, s as manifestDigest } from "./toolchain-DkUflduf.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-CNIBTIOv.mjs";
 import { createHash } from "node:crypto";
 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 { InvalidArgumentError } from "commander";
-import { OFFLOAD_MODES, buildMachinesFile, buildMachinesLock, endpoint, findPeer as findPeer$1, isJsonObject, parseMachine, parseMachine as parseMachine$1, pinnedEndpoint, readBuildMachines, saturation } from "@stim-cli/core/state";
+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 { WebSocket } from "ws";
 //#region src/offload/access-ticket.ts
@@ -95,11 +96,11 @@ function pinnedEndpoint$1(credential, status = tailscaleStatus) {
 //#endregion
 //#region src/offload/build-machines.ts
 /** The build machines named in `offload.machines` that this Mac asked for build access, in that order. */
-function pairedMachines(entries = configuredMachines()) {
+function pairedMachines(entries = configuredMachines$1()) {
 	const credentials = readBuildMachines();
 	return entries.flatMap((entry) => credentials.filter((each) => each.machine === entry));
 }
-function configuredMachines() {
+function configuredMachines$1() {
 	const machines = loadConfig$1()?.offload?.machines;
 	return Array.isArray(machines) ? machines.filter((entry) => typeof entry === "string") : [];
 }
@@ -120,7 +121,7 @@ function updateCredentials(change) {
 		}
 	}, { ensureParent: () => mkdirSync(dir, { recursive: true }) });
 }
-function note(title, detail, fix = null) {
+function note$1(title, detail, fix = null) {
 	return {
 		code: "build-machine",
 		level: "note",
@@ -129,7 +130,7 @@ function note(title, detail, fix = null) {
 		fix
 	};
 }
-const approval = (entry, deviceId) => `A person on ${entry} approves it with \`stim-server devices grant ${deviceId} --build\`.`;
+const approval$1 = (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",
@@ -195,7 +196,7 @@ async function requestAccess(entry, peer, port, deviceName, io) {
 				state: "unreachable",
 				dnsName: peer.dnsName
 			},
-			finding: note(`Could not ask ${entry} for build access`, reason)
+			finding: note$1(`Could not ask ${entry} for build access`, reason)
 		};
 	}
 	const credential = {
@@ -217,7 +218,7 @@ async function requestAccess(entry, peer, port, deviceName, io) {
 			deviceId: credential.deviceId,
 			requestedAt: credential.requestedAt
 		},
-		finding: note(`Asked ${entry} for build access`, `The request lapses at ${reply.result.approval.expiresAt}.`, approval(entry, credential.deviceId))
+		finding: note$1(`Asked ${entry} for build access`, `The request lapses at ${reply.result.approval.expiresAt}.`, approval$1(entry, credential.deviceId))
 	};
 }
 async function inspectMachine(entry, status, deviceName, fix, io, check) {
@@ -227,7 +228,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 			machine: entry,
 			state: "invalid"
 		},
-		finding: note(`Build machine ${entry} is not a tailnet name`, "Expected `name` or `name:port`.")
+		finding: note$1(`Build machine ${entry} is not a tailnet name`, "Expected `name` or `name:port`.")
 	};
 	const peer = findPeer$1(status, parsed.name);
 	if (peer === "missing" || peer === "ambiguous") {
@@ -237,7 +238,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 				machine: entry,
 				state: "not-on-tailnet"
 			},
-			finding: note(`Build machine ${entry} is not on this tailnet`, detail)
+			finding: note$1(`Build machine ${entry} is not on this tailnet`, detail)
 		};
 	}
 	const credential = readBuildMachines().find((each) => each.machine === entry);
@@ -252,7 +253,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 			deviceId: credential.deviceId,
 			requestedAt: credential.requestedAt
 		},
-		finding: note(`Build machine ${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 offload.machines, run \`stim doctor --fix\` to forget the old pairing, then add it back and run \`stim doctor --fix\` again.`)
+		finding: note$1(`Build machine ${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 offload.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);
@@ -261,7 +262,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 				...known,
 				state: "not-asked"
 			},
-			finding: note(`Build machine ${entry} has not approved this Mac`, "This Mac has not asked it for build access.", "Run `stim doctor --fix` to ask.")
+			finding: note$1(`Build machine ${entry} has not approved this Mac`, "This Mac has not asked it for build access.", "Run `stim doctor --fix` to ask.")
 		};
 	}
 	const paired = {
@@ -311,7 +312,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 				...paired,
 				state: "pending"
 			},
-			finding: note(`Build machine ${entry} has not approved this Mac yet`, `Requested at ${credential.requestedAt}.`, approval(entry, credential.deviceId))
+			finding: note$1(`Build machine ${entry} has not approved this Mac yet`, `Requested at ${credential.requestedAt}.`, approval$1(entry, credential.deviceId))
 		};
 	}
 	if ("error" in reply && reply.error.code === "unauthorized") {
@@ -321,7 +322,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 				...paired,
 				state: "revoked"
 			},
-			finding: note(`Build machine ${entry} no longer accepts this Mac`, `${reply.error.message} It was revoked, or the request lapsed before approval.`, "Run `stim doctor --fix` to ask again.")
+			finding: note$1(`Build machine ${entry} no longer accepts this Mac`, `${reply.error.message} It was revoked, or the request lapsed before approval.`, "Run `stim doctor --fix` to ask again.")
 		};
 	}
 	const reason = "failed" in reply ? reply.failed : "error" in reply ? reply.error.message : "unexpected reply";
@@ -330,7 +331,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 			...paired,
 			state: "unreachable"
 		},
-		finding: note(`Could not reach build machine ${entry}`, reason, `Check that stim-server runs on ${entry}. To keep it running there, run \`stim-server service install --serve\` on ${entry}.`)
+		finding: note$1(`Could not reach build machine ${entry}`, reason, `Check that stim-server runs on ${entry}. To keep it running there, run \`stim-server service install --serve\` on ${entry}.`)
 	};
 }
 /**
@@ -340,7 +341,7 @@ async function inspectMachine(entry, status, deviceName, fix, io, check) {
 * 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()) {
+async function inspectBuildMachines({ fix, check = null }, io = realIo, entries = configuredMachines$1()) {
 	const unnamed = (each) => !entries.includes(each.machine);
 	if (fix && readBuildMachines().some(unnamed)) updateCredentials((credentials) => credentials.filter((each) => !unnamed(each)));
 	if (entries.length === 0) return {
@@ -349,7 +350,7 @@ async function inspectBuildMachines({ fix, check = null }, io = realIo, entries
 	};
 	const status = io.status();
 	if (!isJsonObject(status)) return {
-		findings: [note("Build machines are unreachable", "offload.machines names build machines, but Tailscale is not running.")],
+		findings: [note$1("Build machines are unreachable", "offload.machines names build machines, but Tailscale is not running.")],
 		machines: entries.map((machine) => ({
 			machine,
 			state: "tailscale-off"
@@ -1240,7 +1241,7 @@ async function offloadBuild({ choice, expectedFingerprint, request, stagingDir,
 			ok: true,
 			machine,
 			artifactPath,
-			...request.platform === "macos" && typeof declared.handoff === "string" && /^[0-9a-f]{64}$/.test(declared.handoff) ? { handoff: {
+			...typeof declared.handoff === "string" && /^[0-9a-f]{64}$/.test(declared.handoff) ? { handoff: {
 				nodeId: choice.credential.nodeId,
 				token: declared.handoff,
 				sha256: digest
@@ -1365,4 +1366,261 @@ function offloadCheck(projectRoot, targets) {
 	};
 }
 //#endregion
-export { readHostPermissions as S, findPeer$1 as _, offloadBuild as a, realIo as b, placementLoad as c, OffloadRefusal as d, namedBuildMachine as f, endpoint as g, inspectBuildMachines as h, closeOffload as i, remotePhaseText as l, resolveBuildPlacement as m, buildPlacementCandidates as n, offloadCheck as o, parseBuildMachineOption as p, chooseBuildMachine as r, offloadPlacement as s, BuildConnection as t, simulatorRuntime as u, parseMachine$1 as v, readAccessTicket as x, pinnedEndpoint$1 as y };
+//#region src/device-host/machines.ts
+function note(title, detail, fix = null) {
+	return {
+		code: "device-host-machine",
+		level: "note",
+		title,
+		detail,
+		fix
+	};
+}
+const approval = (machine, id) => `A person on ${machine} approves it with \`stim-server devices grant ${id} --device-host\`.`;
+function configuredMachines() {
+	const hosting = loadConfig$1()?.hosting;
+	if (hosting !== void 0 && !isJsonObject(hosting)) return null;
+	const machines = hosting?.machines;
+	if (machines === void 0) return [];
+	return acceptsShape(settingDefinition("hosting.machines"), machines) ? machines : null;
+}
+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(`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(),
+		...ticket ? { ticketHash: ticket.ticketHash } : {}
+	};
+	return {
+		report: {
+			machine,
+			dnsName: peer.dnsName,
+			state: "pending",
+			deviceId: credential.deviceId,
+			requestedAt: credential.requestedAt
+		},
+		finding: note(`Asked ${machine} for hosting access`, `The request lapses at ${reply.result.approval.expiresAt}.`, approval(machine, credential.deviceId)),
+		credential
+	};
+}
+/** Reports separately approved hosting machines. Only --fix asks or forgets credentials; every token stays pinned. */
+async function inspectDeviceHostMachines({ fix }, io = realIo, entries = configuredMachines()) {
+	if (entries === null) return {
+		findings: [note("Invalid hosting.machines setting", "Use a hosting 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("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: "hosting machine approval"
+	});
+	if (!claim.acquired) {
+		releaseClaim(claim.pending);
+		return unavailable("busy", note("Hosting machine 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("Hosting machines are unreachable", "hosting.machines names hosting machines, 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(`Hosting machine ${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(`Hosting machine ${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(`Hosting machine ${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(`Hosting machine ${machine} repeats a named node`, "Name each tailnet node and serve port only once in hosting.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(`Hosting machine ${machine} is a different tailnet node`, "Stim refuses to connect or send the saved token.", `If that Mac was replaced, remove ${machine} from hosting.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 ? {
+							...each,
+							state: "approved"
+						} : 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(`Hosting machine ${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,
+						state: "pending"
+					});
+					inspected.findings.push(note(`Hosting machine ${machine} has not approved this Mac yet`, `Requested at ${credential.requestedAt}.`, approval(machine, credential.deviceId)));
+					continue;
+				}
+				if (!ask) {
+					inspected.machines.push({
+						...known,
+						state: revoked ? "revoked" : "unreachable"
+					});
+					inspected.findings.push(note(`Hosting machine ${machine} ${revoked ? "no longer accepts this Mac" : "did not confirm hosting access"}`, "The saved token and pinned node are preserved.", revoked ? "Run `stim doctor --fix` to ask again." : `Check stim-server and its tailnet serve route on ${machine}, then run doctor again.`));
+					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(`Hosting machine ${machine} has not approved this Mac`, "This Mac has not asked for hosting access.", "Run `stim doctor --fix` to ask."));
+			}
+		}
+		return inspected;
+	} finally {
+		releaseClaim(claim.acquired);
+	}
+}
+//#endregion
+export { resolveBuildPlacement as _, chooseBuildMachine as a, pinnedEndpoint$1 as b, offloadCheck as c, remotePhaseText as d, simulatorRuntime as f, resolveBuildMachine as g, parseBuildMachineOption as h, buildPlacementCandidates as i, offloadPlacement as l, namedBuildMachine as m, inspectDeviceHostMachines as n, closeOffload as o, OffloadRefusal as p, BuildConnection as r, offloadBuild as s, configuredMachines as t, placementLoad as u, inspectBuildMachines as v, realIo as x, parseMachine$1 as y };