stim 1.25.0 → 1.27.0

package/dist/{hosted-android-Bvb2-ZxD.mjs → hosted-android-BMKzUNnY.mjs}

@@ -1,7 +1,7 @@
-import { c as throwIfCancelled } from "./exec-VFRpu1iA.mjs";
-import { c as call, l as connectHost } from "./hosted-client-rsRqysJc.mjs";
-import { i as requestHostedMetro } from "./metro-gateway-Bp9gJQAN.mjs";
-import { a as stopHostedNative, i as prepareHostedNative, r as placeHostedNative } from "./hosted-native-BxTizGU2.mjs";
+import { c as throwIfCancelled } from "./exec-aULwtNly.mjs";
+import { c as call, l as connectHost } from "./hosted-client-D7Pk_Oo1.mjs";
+import { i as requestHostedMetro } from "./metro-gateway-BnHdqMO_.mjs";
+import { a as stopHostedNative, i as prepareHostedNative, r as placeHostedNative } from "./hosted-native-CdgaiuyP.mjs";
 //#region src/device-host/hosted-android.ts
 async function prepareHostedAndroid(machine, selectors, recorded, mode) {
 	return await prepareHostedNative(machine, selectors, recorded, "android", false, mode);

package/dist/{hosted-client-rsRqysJc.mjs → hosted-client-D7Pk_Oo1.mjs}

@@ -1,7 +1,7 @@
-import { c as throwIfCancelled, o as cancellableSleep } from "./exec-VFRpu1iA.mjs";
-import { rt as resolveEndpoint } from "./config-BZhXY15H.mjs";
-import { t as BuildConnection } from "./client-BQsmyp_-.mjs";
-import { d as configuredMachines } from "./selection-D5cxEl3t.mjs";
+import { c as throwIfCancelled, o as cancellableSleep } from "./exec-aULwtNly.mjs";
+import { Y as diagnoseConnectFailure, ot as resolveEndpoint } from "./config-Cn94Jc0g.mjs";
+import { t as BuildConnection } from "./client-xsdxrhWA.mjs";
+import { g as configuredMachines } from "./selection-Bs8phwhN.mjs";
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { join } from "node:path";
@@ -50,14 +50,18 @@ async function connectHost(machine, timeoutMs = CONNECT_TIMEOUT_MS, strict = fal
 	signal?.throwIfAborted();
 	if (typeof target === "string") throw Object.assign(/* @__PURE__ */ new Error(`Stim does not connect to ${machine}: ${target}.`), { code: "STIM_HOSTING_REFUSED" });
 	const opened = await BuildConnection.open(target, credential.serverKey, timeoutMs, "device-host", signal).catch((error) => {
-		throw Object.assign(new Error(`${machine} is unreachable. Check stim-server and its tailnet serve route on ${machine}.`, { cause: error }), { code: strict ? "STIM_HOSTING_REFUSED" : "closed" });
+		throw Object.assign(new Error(`${machine} is unreachable. Run stim doctor to see which layer failed.`, { cause: error }), { code: strict ? "STIM_HOSTING_REFUSED" : "closed" });
 	});
 	if (signal?.aborted && opened instanceof BuildConnection) opened.close();
 	signal?.throwIfAborted();
-	if (!(opened instanceof BuildConnection)) throw Object.assign(/* @__PURE__ */ new Error(opened.code === "server-outdated" ? `${machine} runs a stim-server that speaks an older protocol than this Stim. Run stim doctor for the command that updates it there, then retry.` : opened.refused ? `${machine} refused this machine: ${opened.failure.replace(/\.+$/, "")}. Run stim doctor.` : `${machine} is unreachable: ${opened.failure}. Check stim-server and its tailnet serve route on ${machine}.`), {
-		code: strict ? "STIM_HOSTING_REFUSED" : opened.refused ? "STIM_HOSTING_REFUSED" : opened.code ?? "closed",
-		hostCode: opened.code
-	});
+	if (!(opened instanceof BuildConnection)) {
+		const diagnosis = opened.refused || opened.code === "server-outdated" ? null : await diagnoseConnectFailure(machine, opened, signal);
+		throw Object.assign(new Error(opened.code === "server-outdated" ? `${machine} runs a stim-server that speaks an older protocol than this Stim. Run stim doctor for the command that updates it there, then retry.` : opened.refused ? `${machine} refused this machine: ${opened.failure.replace(/\.+$/, "")}. Run stim doctor.` : diagnosis?.message ?? `${machine} is unreachable: ${opened.failure}. Run stim doctor to see which layer failed.`), {
+			code: strict ? "STIM_HOSTING_REFUSED" : opened.refused ? "STIM_HOSTING_REFUSED" : opened.code ?? "closed",
+			hostCode: opened.code,
+			...diagnosis ? { remedy: diagnosis.remedy } : {}
+		});
+	}
 	return {
 		machine,
 		credential,

package/dist/{hosted-logs-CWKGYWNX.mjs → hosted-logs-B1gqQuva.mjs}

@@ -1,11 +1,11 @@
-import { t as getExecutor } from "./exec-VFRpu1iA.mjs";
-import { d as workspaceDir, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
-import { B as deviceSlotFileKey, et as parseMachine$1, q as validateDeviceSlot } from "./config-BZhXY15H.mjs";
-import { l as phaseLine } from "./command-output-BBvS1H6v.mjs";
-import { n as macosDir } from "./state-DPaM3u5K.mjs";
-import { n as androidLogGroups, r as isAndroidCrashText } from "./android-saBeB4lr.mjs";
-import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
-import { c as call } from "./hosted-client-rsRqysJc.mjs";
+import { t as getExecutor } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, k as workspaceLogsDir$1 } from "./workspace-state-BjqdjnJR.mjs";
+import { B as deviceSlotFileKey, q as validateDeviceSlot, rt as parseMachine$1 } from "./config-Cn94Jc0g.mjs";
+import { l as phaseLine } from "./command-output-Dj-WT4BP.mjs";
+import { n as macosDir } from "./state-CZxLyetD.mjs";
+import { n as androidLogGroups, r as isAndroidCrashText } from "./android-Deb9X3_Y.mjs";
+import { c as readNdjsonGenerations$1, i as createNdjsonWriter } from "./ndjson-Dy2W4vRa.mjs";
+import { c as call } from "./hosted-client-D7Pk_Oo1.mjs";
 import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { LOG_ROTATE_BYTES, ambientWrite, withDirLockAsync } from "@stim-cli/core";
@@ -205,10 +205,10 @@ async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPag
 		if (!isJsonObject(result) || !cursor || !Array.isArray(result.records) || !result.records.every(isJsonObject) || typeof result.more !== "boolean") throw new Error(`${host.machine} answered device-host.logs.query with an unexpected result.`);
 		signal?.throwIfAborted();
 		await commitPage(root, placement.session, before, result.records, cursor, target);
-		if (!result.more) return;
 		const nextCheckpoint = typeof result.checkpoint === "number" ? result.checkpoint : void 0;
+		if (!result.more) return nextCheckpoint;
 		if (sameCursor(cursor, before) && nextCheckpoint === checkpoint) {
-			if (target.platform === "macos" && !final) return;
+			if (target.platform === "macos" && !final) return void 0;
 			throw new Error("Hosted native logs made no progress; keeping the logs already copied here.");
 		}
 		checkpoint = nextCheckpoint;
@@ -217,10 +217,16 @@ async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPag
 }
 async function pullHostedNativeLogs(root, slot, placement, host, final = false, platform = "ios", signal) {
 	if (!host.connection.supports(platform === "ios" ? "hosted-ios-data" : "hosted-android-data")) throw new Error(`${host.machine} needs a newer stim-server to collect hosted ${platform === "ios" ? "iOS" : "Android"} native logs.`);
-	await pullHostedMacosLogs(root, placement, host, {
+	return await pullHostedMacosLogs(root, placement, host, {
 		platform,
 		slot
 	}, final ? 1024 : MAX_PAGES, final, signal);
 }
+function readHostedNativeLogs(root, platform, slot) {
+	return readNdjsonGenerations$1(hostLogFile(root, {
+		platform,
+		slot
+	}));
+}
 //#endregion
-export { removeAgentAccess as a, agentAccess as i, pullHostedNativeLogs as n, closeAgentConnection as r, pullHostedMacosLogs as t };
+export { agentAccess as a, closeAgentConnection as i, pullHostedNativeLogs as n, removeAgentAccess as o, readHostedNativeLogs as r, pullHostedMacosLogs as t };

package/dist/hosted-logs-sync-Dg3qrZmV.mjs

@@ -0,0 +1,195 @@
+import { n as pullHostedNativeLogs, r as readHostedNativeLogs, t as pullHostedMacosLogs } from "./hosted-logs-B1gqQuva.mjs";
+import { l as phaseLine } from "./command-output-Dj-WT4BP.mjs";
+import { l as connectHost } from "./hosted-client-D7Pk_Oo1.mjs";
+import { n as readHostedIos, t as readHostedAndroid } from "./ios-state-BZ03NFgF.mjs";
+import "./hosted-macos-B9w4H8hc.mjs";
+import { watch } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { ambientWrite, configDir } from "@stim-cli/core";
+import { readMacosRecord, workspaceStateFile } from "@stim-cli/core/state";
+//#region src/device-host/hosted-logs-sync.ts
+const WATCH_RECHECK_MS = 100;
+function warn(context, machine, error) {
+	const text = `${warning(machine, error)}\n`;
+	if (context) context.output("stderr", text);
+	else ambientWrite("stderr", text);
+}
+function warning(machine, error) {
+	const message = error.message.replace(/\.$/, "");
+	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, platform = "ios", context) {
+	let host;
+	const cancel = () => host?.connection.close();
+	context?.signal.addEventListener("abort", cancel, { once: true });
+	try {
+		host = await connectHost(placement.machine, void 0, false, context?.signal);
+		if (slot !== void 0) await pullHostedNativeLogs(root, slot, placement, host, false, platform, context?.signal);
+		else await pullHostedMacosLogs(root, placement, host, void 0, void 0, false, context?.signal);
+		return true;
+	} catch (error) {
+		context?.signal.throwIfAborted();
+		if (!warnings?.has(placement.machine)) {
+			warn(context, placement.machine, error);
+			warnings?.add(placement.machine);
+		}
+		return false;
+	} finally {
+		context?.signal.removeEventListener("abort", cancel);
+		host?.connection.close();
+	}
+}
+function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3, slot, platform = "ios", context, onPulled, onFailed } = {}) {
+	let host;
+	const controller = new AbortController();
+	const signal = context ? AbortSignal.any([context.signal, controller.signal]) : controller.signal;
+	const cancel = () => host?.connection.close();
+	signal.addEventListener("abort", cancel, { once: true });
+	let retryAt = 0;
+	let stopped = false;
+	let running = false;
+	const tick = async () => {
+		if (running || stopped || signal.aborted || Date.now() < retryAt) return;
+		running = true;
+		try {
+			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, void 0, false, signal);
+			const through = slot !== void 0 ? await pullHostedNativeLogs(root, slot, placement, host, false, platform, signal) : await pullHostedMacosLogs(root, placement, host, void 0, void 0, false, signal);
+			failing = false;
+			onPulled?.(through);
+		} catch (error) {
+			host?.connection.close();
+			host = void 0;
+			if (signal.aborted) return;
+			onFailed?.();
+			if (!failing) warn(context, (slot !== void 0 ? (platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))[slot] : readMacosRecord(root)?.host)?.machine ?? "the host", error);
+			failing = true;
+			retryAt = Date.now() + retryMs;
+		} finally {
+			running = false;
+		}
+	};
+	const timer = setInterval(() => void tick(), intervalMs);
+	return () => {
+		stopped = true;
+		controller.abort();
+		signal.removeEventListener("abort", cancel);
+		clearInterval(timer);
+		host?.connection.close();
+	};
+}
+/** Copies a hosted slot's native logs while its launch is verified; a failed copy stops holding the launch windows. */
+function followHostedLaunchLogs(root, slot, platform, since, context) {
+	let through = null;
+	let failed = false;
+	const stop = followHostedMacosLogs(root, {
+		slot,
+		platform,
+		context,
+		onPulled: (covered) => {
+			failed = false;
+			if (covered !== void 0) through = Math.max(through ?? covered, covered);
+		},
+		onFailed: () => {
+			failed = true;
+		}
+	});
+	const records = () => readHostedNativeLogs(root, platform, slot);
+	return {
+		readDeviceRecords: records,
+		readNativeCrashes: () => records().filter((record) => record.event === "native_crash" && Number(record.ts) >= since),
+		deviceLogsThrough: () => failed ? Number.POSITIVE_INFINITY : through,
+		stop
+	};
+}
+async function syncHostedLogs(root, context) {
+	const macos = readMacosRecord(root)?.host;
+	const warnings = /* @__PURE__ */ new Set();
+	return (await Promise.all([
+		...macos ? [syncHostedMacosLogs(root, macos, void 0, warnings, "ios", context)] : [],
+		...Object.entries(readHostedIos(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings, "ios", context)),
+		...Object.entries(readHostedAndroid(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings, "android", context))
+	])).every(Boolean);
+}
+function followHostedLogs(root, failing, context) {
+	const stops = /* @__PURE__ */ new Map();
+	let closed = false;
+	const refresh = () => {
+		if (closed) return;
+		const active = /* @__PURE__ */ new Set();
+		if (readMacosRecord(root)?.host) {
+			active.add("macos");
+			if (!stops.has("macos")) stops.set("macos", followHostedMacosLogs(root, {
+				failing,
+				context
+			}));
+		}
+		for (const platform of ["ios", "android"]) for (const slot of Object.keys(platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))) {
+			const key = `${platform}:${slot}`;
+			active.add(key);
+			if (!stops.has(key)) stops.set(key, followHostedMacosLogs(root, {
+				failing,
+				slot,
+				platform,
+				context
+			}));
+		}
+		for (const [key, stop] of stops) {
+			if (active.has(key)) continue;
+			stop();
+			stops.delete(key);
+		}
+	};
+	const stateFile = workspaceStateFile(root);
+	const home = resolve(configDir());
+	let watcher = null;
+	let recheck;
+	const observe = () => {
+		if (closed) return;
+		watcher?.close();
+		watcher = null;
+		clearTimeout(recheck);
+		let directory = dirname(stateFile);
+		for (;;) try {
+			const entry = relative(directory, stateFile).split(sep)[0];
+			const next = watch(directory, (_event, name) => {
+				if (name !== null && name.toString() !== entry) return;
+				if (directory !== dirname(stateFile)) observe();
+				refresh();
+			});
+			next.on("error", () => {
+				next.close();
+				if (watcher === next) watcher = null;
+			});
+			next.unref();
+			watcher = next;
+			recheck = setTimeout(refresh, WATCH_RECHECK_MS);
+			recheck.unref();
+			return;
+		} catch (error) {
+			if (directory === home || !(error instanceof Error && "code" in error && error.code === "ENOENT")) return;
+			directory = dirname(directory);
+		}
+	};
+	observe();
+	refresh();
+	const timer = setInterval(() => {
+		observe();
+		refresh();
+	}, 1e4);
+	return () => {
+		closed = true;
+		watcher?.close();
+		clearTimeout(recheck);
+		clearInterval(timer);
+		for (const stop of stops.values()) stop();
+	};
+}
+//#endregion
+export { followHostedLogs as n, syncHostedLogs as r, followHostedLaunchLogs as t };

package/dist/{hosted-macos-d0pv9Tth.mjs → hosted-macos-B9w4H8hc.mjs}

@@ -1,9 +1,9 @@
-import { o as cancellableSleep } from "./exec-VFRpu1iA.mjs";
-import { a as removeAgentAccess, i as agentAccess, r as closeAgentConnection, t as pullHostedMacosLogs } from "./hosted-logs-CWKGYWNX.mjs";
-import { l as phaseLine } from "./command-output-BBvS1H6v.mjs";
-import { n as macosDir } from "./state-DPaM3u5K.mjs";
-import { d as runCancellationSignal } from "./native-run-D5OJsGwA.mjs";
-import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, o as attach, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-rsRqysJc.mjs";
+import { o as cancellableSleep } from "./exec-aULwtNly.mjs";
+import { a as agentAccess, i as closeAgentConnection, o as removeAgentAccess, t as pullHostedMacosLogs } from "./hosted-logs-B1gqQuva.mjs";
+import { l as phaseLine } from "./command-output-Dj-WT4BP.mjs";
+import { n as macosDir } from "./state-CZxLyetD.mjs";
+import { ot as runCancellationSignal } from "./toolchain-CbCG6C5Z.mjs";
+import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, o as attach, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-D7Pk_Oo1.mjs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { ambientContext, ambientWrite } from "@stim-cli/core";

package/dist/{hosted-native-BxTizGU2.mjs → hosted-native-CdgaiuyP.mjs}

@@ -1,11 +1,10 @@
-import { o as cancellableSleep } from "./exec-VFRpu1iA.mjs";
-import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
-import { a as removeAgentAccess, i as agentAccess, n as pullHostedNativeLogs, r as closeAgentConnection } from "./hosted-logs-CWKGYWNX.mjs";
-import { l as withWorkspaceStateLockAsync, r as readWorkspaceState$1 } from "./workspace-state-CPSp3mav.mjs";
-import { d as runCancellationSignal } from "./native-run-D5OJsGwA.mjs";
-import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, n as OFFER_TIMEOUT_MS, o as attach, p as requireHostedAppMode, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-rsRqysJc.mjs";
-import { a as requireHostedMetro, i as requestHostedMetro, n as closeHostedMetro } from "./metro-gateway-Bp9gJQAN.mjs";
-import { s as writeHostedNative } from "./ios-state-CT9nV5SP.mjs";
+import { o as cancellableSleep, x as withDrainingCancellation } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1 } from "./workspace-state-BjqdjnJR.mjs";
+import { a as agentAccess, i as closeAgentConnection, n as pullHostedNativeLogs, o as removeAgentAccess } from "./hosted-logs-B1gqQuva.mjs";
+import { ot as runCancellationSignal } from "./toolchain-CbCG6C5Z.mjs";
+import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, n as OFFER_TIMEOUT_MS, o as attach, p as requireHostedAppMode, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-D7Pk_Oo1.mjs";
+import { a as requireHostedMetro, i as requestHostedMetro, n as closeHostedMetro } from "./metro-gateway-BnHdqMO_.mjs";
+import { s as writeHostedNative } from "./ios-state-BZ03NFgF.mjs";
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -125,12 +124,19 @@ function hostedMetroPortProbe(machine, note) {
 		return !window.busy.has(port);
 	};
 }
-async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId, selectors, release, mode = release ? "release" : "development", devClientScheme, reserved, note, enterPhase = () => {}, metro = requestHostedMetro, metroPort, platform = "ios" }) {
+function placeHostedNative(target, options) {
+	const context = ambientContext();
+	return withDrainingCancellation(context, runCancellationSignal(context), () => placeHostedNativeOnce(target, options));
+}
+async function placeHostedNativeOnce(target, { root, slot, bundle, handoff, bundleId, selectors, release, mode = release ? "release" : "development", devClientScheme, reserved, note, enterPhase = () => {}, metro = requestHostedMetro, metroPort, platform = "ios" }) {
 	let host = target.host;
+	const signal = runCancellationSignal(ambientContext());
+	const closeOnAbort = () => host.connection.close();
+	signal?.addEventListener("abort", closeOnAbort, { once: true });
 	try {
 		if (mode === "development" && metro === requestHostedMetro) requireHostedMetro(root);
 		enterPhase("device");
-		host = await connectHost(host.machine, void 0, true);
+		host = await connectHost(host.machine, void 0, true, signal);
 		target.host = host;
 		requireHostedAppMode(host, platform, mode);
 		let session = (target.session ? await attach(host, target.session.id, void 0, platform) : null) ?? await reserveHostedNative(host, target, {
@@ -267,6 +273,7 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 	} catch (error) {
 		throw hostingRefusal(host.machine, error);
 	} finally {
+		signal?.removeEventListener("abort", closeOnAbort);
 		if (platform === "android") host.connection.close();
 	}
 }
@@ -287,13 +294,6 @@ async function stopHostedNative(root, slot, signal, platform = "ios") {
 		signal?.addEventListener("abort", cancel, { once: true });
 		try {
 			host = await connectHost(placement.machine, void 0, false, signal);
-			try {
-				await pullHostedNativeLogs(root, name, placement, host, true, platform, signal);
-			} catch (error) {
-				signal?.throwIfAborted();
-				ambientWrite("stderr", `Could not copy final native logs from ${placement.machine}: ${error.message}\n`);
-			}
-			signal?.throwIfAborted();
 			const stopped = await settle(host, hostedSession(host, await call(host, "device-host.stop", { session: placement.session }), platform), ["stopping"], SESSION_TIMEOUT_MS, platform, signal);
 			signal?.throwIfAborted();
 			if (stopped.state !== "stopped") throw unknownSession(host, stopped);

package/dist/{idle-shutdown-BIyfl0Zj.mjs → idle-shutdown-Cbvo5KEh.mjs}

@@ -1,11 +1,13 @@
-import { V as deviceSlotKey, _ as loadConfig$1 } from "./config-BZhXY15H.mjs";
-import { o as formatLongDuration } from "./command-output-BBvS1H6v.mjs";
-import { r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-CPSp3mav.mjs";
-import { A as workspaceBuildInProgress, T as collectOwnedDeviceActivity } from "./budget-HyShrIpL.mjs";
+import { k as workspaceLogsDir$1, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-BjqdjnJR.mjs";
+import { V as deviceSlotKey, _ as loadConfig$1 } from "./config-Cn94Jc0g.mjs";
+import { o as formatLongDuration } from "./command-output-Dj-WT4BP.mjs";
+import { i as createNdjsonWriter } from "./ndjson-Dy2W4vRa.mjs";
+import { L as workspaceBuildInProgress, ft as teardownOwnedIosSim, j as collectOwnedDeviceActivity, ut as teardownOwnedAvd } from "./workspaces-DFbj07jp.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { A as teardownOwnedIosSim, O as teardownOwnedAvd } from "./workspaces-C9w4aeXF.mjs";
-import { _ as workspaceDeviceLastUseAt } from "./activity-BpjwrQXU.mjs";
-import { d as listAllIosSims } from "./ios-BQzvJlzw.mjs";
+import { _ as workspaceDeviceLastUseAt } from "./activity-Cd-ysFes.mjs";
+import { d as listAllIosSims } from "./ios-E26qSpkb.mjs";
+import { join } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { DEVICE_IDLE_SHUTDOWN_KEY, DEVICE_RECLAIM_REASON, readDeviceIdleShutdowns } from "@stim-cli/core/state";
 //#region src/devices/idle-shutdown.ts
 const SIM_LIST_TIMEOUT_MS = 1e4;
@@ -58,6 +60,15 @@ function dueIdleDevices(root, idleMs, now = Date.now()) {
 		}];
 	});
 }
+/** Appends an idle shutdown record to the workspace's metro.ndjson, where the supervisor writes its own. */
+function writeIdleShutdownEvent(root, event) {
+	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	writer.write({
+		src: "metro",
+		...event
+	});
+	writer.close();
+}
 /**
 * Shuts down, through centralized teardown, each of the workspace's owned devices that is still idle for `idleMs`,
 * and records why. The caller holds the workspace's native-run lock, so no `ios` or `android` run is booting or
@@ -108,7 +119,8 @@ async function shutDownIdleDevices(root, idleMs, log, now = Date.now(), { only,
 		} else if (outcome.status !== "missing") log({
 			level: "warn",
 			event: "device_idle_shutdown_failed",
-			msg: `could not shut down idle ${what}: ${outcome.reason}`
+			msg: `could not shut down idle ${what}: ${outcome.reason}`,
+			...outcome.status === "skipped" ? { skipped: true } : {}
 		});
 	}
 	return shutDown;
@@ -127,4 +139,4 @@ async function clearDeviceIdleShutdown(root, platform, slot = "default") {
 	});
 }
 //#endregion
-export { dueIdleDevices as n, shutDownIdleDevices as r, clearDeviceIdleShutdown as t };
+export { writeIdleShutdownEvent as i, dueIdleDevices as n, shutDownIdleDevices as r, clearDeviceIdleShutdown as t };