stim 1.14.0 → 1.16.0

package/dist/{reload-BiniwsSZ.mjs → reload-rM9jV1fz.mjs}

@@ -1,14 +1,18 @@
-import { B as deviceSlotPlatforms, V as parseDeviceSlotKey, p as getProject } from "./config-lvc7d3C2.mjs";
-import { c as resolveProjectMetro, g as recordWorkspaceUse } from "./metro-CcEo8Fl8.mjs";
-import { i as findCommandWorkspace } from "./project-CWlvEaeN.mjs";
-import { f as readWorkspaceLaunches } from "./state-DHqvsbqC.mjs";
-import { f as refuseNoProject, l as phaseLine } from "./command-output-DVcpw6eE.mjs";
-import { q as resolveOwnedAvdSerial } from "./android-d6rGq1pA.mjs";
-import { a as readWebRecord, l as webFacts, r as cdpEndpoint } from "./state-Dk9RVXI7.mjs";
-import { S as resolveOwnedIosSim } from "./ios-BwDPrnYQ.mjs";
-import { h as iosAppProcess, o as androidAppProcess } from "./app-install-BpgSgkJj.mjs";
-import { n as nativeRunCommand } from "./slot-launch-D5t8EiMf.mjs";
-import { n as sendToOwnedPage, t as liveWebRecord } from "./page-BHUzTDFt.mjs";
+import { B as parseDeviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { a as findCommandWorkspace } from "./project-Du91Ilvc.mjs";
+import { l as resolveProjectMetro } from "./metro-BeK1ZPz1.mjs";
+import { i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { o as readWebRecord, r as cdpEndpoint, u as webFacts } from "./state-C1jB7Q8q.mjs";
+import { f as readWorkspaceLaunches } from "./state-DcW6vOd_.mjs";
+import { J as resolveOwnedAvdSerial } from "./android-B_NumVyQ.mjs";
+import { w as resolveOwnedIosSim } from "./ios-BaInn3sW.mjs";
+import { l as probeHostedSession } from "./hosted-client-a-WmqE2L.mjs";
+import { p as ensureMetroReverse, s as androidAppProcess, v as iosAppProcess } from "./app-install-CKWdbXIX.mjs";
+import { n as nativeRunCommand } from "./slot-launch-B8VrHxn1.mjs";
+import { t as readHostedIos } from "./ios-state-DS5UpYTH.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-QF_Ke10s.mjs";
+import { hostedIosRecords } from "@stim-cli/core/state";
 import chalk from "chalk";
 import { WebSocket } from "ws";
 //#region src/engine/reload.ts
@@ -31,7 +35,11 @@ function peerMatches(query, role, appId) {
 	if (role === "ios") return query.get("role")?.toLowerCase() === "ios";
 	return query.get("app") === appId;
 }
-function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS }) {
+/**
+* Asks Metro for its peers and reloads the ones matching `role` and `appId`. With `peersOnly`, it sends nothing and
+* only reports the outcome a reload would have, so a caller can wait for the app to connect.
+*/
+function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, peersOnly = false }) {
 	const roleName = ROLE_NAMES[role];
 	return new Promise((resolve) => {
 		const requestId = `stim-reload-${process.pid}-${Date.now()}`;
@@ -72,6 +80,15 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 					const query = peerQuery(metadata);
 					return query ? peerMatches(query, role, appId) : false;
 				});
+				if (rolePeers.length === 0 && peersOnly) {
+					finish({
+						failed: true,
+						noPeer: true,
+						peers,
+						reason: `No ${roleName} React Native app is connected to Metro on port ${port}.`
+					});
+					return;
+				}
 				if (rolePeers.length === 0) {
 					socket.send(JSON.stringify({
 						version: 2,
@@ -86,7 +103,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 					});
 					return;
 				}
-				for (const [id] of rolePeers) socket.send(JSON.stringify({
+				if (!peersOnly) for (const [id] of rolePeers) socket.send(JSON.stringify({
 					version: 2,
 					method: "reload",
 					target: id
@@ -98,7 +115,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 				});
 				return;
 			}
-			socket.send(JSON.stringify({
+			if (!peersOnly) socket.send(JSON.stringify({
 				version: 2,
 				method: "reload"
 			}));
@@ -130,8 +147,16 @@ const DEFAULT_DEPS = {
 		const facts = webFacts(readWebRecord(root));
 		return facts?.status === "unverified" ? "unverified" : liveWebRecord(facts?.record ?? null);
 	},
-	reloadPage: (record) => sendToOwnedPage(record, "Page.reload")
+	reloadPage: (record) => sendToOwnedPage(record, "Page.reload"),
+	ensureReverse: (serial, metroPort) => ensureMetroReverse({
+		serial,
+		metroPort
+	}),
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 };
+const RECONNECT_POLL_MS = 500;
+const RECONNECT_POLLS = 16;
+const RECONNECT_UNOBSERVED_MS = 2500;
 function failure(code, message, remedy) {
 	return {
 		code,
@@ -143,8 +168,9 @@ function describe(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 async function reloadBrowser(browser, metroPort, d) {
+	let pageUrl;
 	try {
-		await d.reloadPage(browser);
+		pageUrl = await d.reloadPage(browser);
 	} catch (error) {
 		return {
 			ok: false,
@@ -157,10 +183,11 @@ async function reloadBrowser(browser, metroPort, d) {
 			platform: "web",
 			deviceId: cdpEndpoint(browser.cdpPort),
 			deviceName: browser.version ?? "Chrome",
-			appId: browser.url,
+			appId: pageUrl,
 			metroPort: metroPort !== null && new URL(browser.url).port === String(metroPort) ? metroPort : null,
 			strategy: "cdp",
-			targets: 1
+			targets: 1,
+			reverseRestored: []
 		}
 	};
 }
@@ -259,15 +286,45 @@ async function runReload({ root, platform = null, deps = {} }) {
 		ok: false,
 		error: failure("STIM_RELOAD_STOPPED", "No owned Chrome is running for this workspace.", "Run `stim web` first.")
 	};
+	const hosted = platform === "android" ? {} : readHostedIos(root);
+	const hostedFailures = {};
+	if (platform !== "android") for (const slot of Object.keys(hostedIosRecords(readWorkspaceState$1(root)))) {
+		if (hosted[slot]) continue;
+		try {
+			readHostedIos(root, slot);
+		} catch (error) {
+			hostedFailures[slot] = {
+				platform: "ios",
+				error: failure("STIM_HOSTING_REFUSED", describe(error), error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? error.remedy : null)
+			};
+		}
+	}
+	const hostedProbes = Object.fromEntries(await Promise.all(Object.entries(hosted).map(async ([slot, placement]) => [slot, await probeHostedSession(placement)])));
 	const launches = d.readLaunches(root);
 	const inspected = Object.entries(launches).flatMap(([key, record]) => {
 		const parsed = parseDeviceSlotKey(key);
 		if (!parsed || platform && parsed.platform !== platform) return [];
+		if (parsed.platform === "ios" && hostedFailures[parsed.slot]) return [];
+		const placement = parsed.platform === "ios" ? hosted[parsed.slot] : void 0;
+		if (placement && record.deviceId === placement.session) {
+			const probe = hostedProbes[parsed.slot];
+			return [probe.state === "ready" ? {
+				platform: "ios",
+				slot: parsed.slot,
+				record,
+				hosted: true,
+				deviceName: `${placement.device?.name ?? "iOS simulator"} on ${placement.machine}`
+			} : {
+				platform: "ios",
+				error: failure("STIM_RELOAD_PROBE_FAILED", `The iOS session on ${placement.machine} is ${probe.state}.`, `Run stim ios --remote ${placement.machine} or stim stop to reconcile it.`)
+			}];
+		}
 		return [inspectTarget(parsed.platform, record, {
 			...project,
 			platforms: deviceSlotPlatforms(project, parsed.slot)
 		}, d, parsed.slot)];
 	});
+	inspected.push(...Object.values(hostedFailures));
 	const live = inspected.filter((target) => !isTargetFailure(target));
 	const livePlatforms = new Set(live.map((target) => target.platform));
 	if (browser) livePlatforms.add("web");
@@ -307,21 +364,47 @@ async function runReload({ root, platform = null, deps = {} }) {
 		ok: false,
 		error: failure("STIM_NO_METRO", `Port ${port} is not serving this workspace's Metro.`, "Run `stim start`, then retry.")
 	};
-	const stopped = processFailure(target.platform, target.record, d, target.slot);
+	const stopped = target.hosted ? null : processFailure(target.platform, target.record, d, target.slot);
 	if (stopped) return {
 		ok: false,
 		error: stopped
 	};
-	const reloaded = await d.reloadMetro(port, {
+	const reverseRestored = [];
+	const reverseChecked = target.platform === "android" ? live.filter((c) => c.platform === "android" && !c.record.release && c.record.metroPort === port) : [];
+	for (const candidate of reverseChecked) {
+		const serial = candidate.record.deviceId;
+		const ensured = d.ensureReverse(serial, port);
+		if (ensured.failed) return {
+			ok: false,
+			error: failure("STIM_RELOAD_FAILED", `Stim could not check or restore the adb reverse for Metro port ${port} on ${serial}: ${ensured.reason}`, `Run \`adb -s ${serial} reverse tcp:${port} tcp:${port}\`, then \`stim reload android\` again.`)
+		};
+		if (ensured.restored) reverseRestored.push(serial);
+	}
+	const request = {
 		role: target.platform,
 		appId: target.record.appId
-	});
+	};
+	const expectedPeers = reverseChecked.filter((c) => c.record.appId === target.record.appId).length;
+	for (let poll = 0; reverseRestored.length && poll < RECONNECT_POLLS; poll++) {
+		const peers = await d.reloadMetro(port, {
+			...request,
+			peersOnly: true
+		});
+		if (peers.broadcast) await d.sleep(RECONNECT_UNOBSERVED_MS);
+		if (peers.unreachable || peers.broadcast || peers.ok && peers.targets >= expectedPeers) break;
+		await d.sleep(RECONNECT_POLL_MS);
+	}
+	const reloaded = await d.reloadMetro(port, request);
 	if (!reloaded.ok) {
-		const stoppedAfterMetro = processFailure(target.platform, target.record, d, target.slot);
+		const stoppedAfterMetro = target.hosted ? null : processFailure(target.platform, target.record, d, target.slot);
 		if (stoppedAfterMetro) return {
 			ok: false,
 			error: stoppedAfterMetro
 		};
+		if (target.hosted) return {
+			ok: false,
+			error: failure("STIM_RELOAD_FAILED", reloaded.reason, `Metro could not confirm a peer for the hosted iOS app. Check the app on its hosting Mac and run stim reload ios again.`)
+		};
 		const snapshot = `agent-device snapshot -i --platform ${target.platform} --${target.platform === "ios" ? "udid" : "serial"} ${target.record.deviceId}`;
 		const relaunch = `agent-device open ${target.record.appId} --platform ${target.platform} --${target.platform === "ios" ? "udid" : "serial"} ${target.record.deviceId} --metro-port ${port} --relaunch`;
 		const firstBundle = target.platform === "ios" ? " If it stays unreachable, an error in the first bundle leaves iOS without a packager connection at all, and no retry will make it a peer." : "";
@@ -342,7 +425,8 @@ async function runReload({ root, platform = null, deps = {} }) {
 			appId: target.record.appId,
 			metroPort: port,
 			strategy,
-			targets: reloaded.targets ?? null
+			targets: reloaded.targets ?? null,
+			reverseRestored
 		}
 	};
 }
@@ -386,7 +470,8 @@ function registerReload(program, deps = {}) {
 				return;
 			}
 			const scope = facts.strategy === "metro-broadcast" ? ` This Metro cannot name its connected apps, so the reload request was broadcast to all of them and Stim cannot confirm ${facts.appId} was one. Check the expected UI on ${facts.deviceId}; if nothing changed, reload from the app's own error screen or dev menu.` : facts.targets && facts.targets > 1 ? ` ${facts.targets} devices are running this app on that Metro and the reload request addressed all of them, not only ${facts.deviceId}.` : "";
-			console.log(`Reload requested for ${facts.appId} on ${facts.deviceName} (${facts.deviceId}) via ${facts.strategy}; ${facts.platform} Metro port ${facts.metroPort}.${scope} Completion is not observed; verify the expected UI and run stim logs --errors.`);
+			const restored = facts.reverseRestored.length ? ` The adb reverse for tcp:${facts.metroPort} was missing on ${facts.reverseRestored.join(", ")}, so Stim restored it first.` : "";
+			console.log(`Reload requested for ${facts.appId} on ${facts.deviceName} (${facts.deviceId}) via ${facts.strategy}; ${facts.platform} Metro port ${facts.metroPort}.${restored}${scope} Completion is not observed; verify the expected UI and run stim logs --errors.`);
 		}
 	});
 }

package/dist/{remote-cache-CcR6o6lI.mjs → remote-cache-C8-V13XN.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir } from "./metro-CcEo8Fl8.mjs";
-import { f as resolvePackageJson } from "./project-CWlvEaeN.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-BVuwQ65v.mjs";
+import { p as resolvePackageJson } from "./project-Du91Ilvc.mjs";
+import { x as workspaceLogsDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-MC0rHlOC.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/run-f4vI6EnK.mjs

@@ -0,0 +1,119 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { i as macosRuntimeClaim, n as macosLogFile, o as updateMacosRecord, r as macosProcess } from "./state-3DwSQIBK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { readMacosRecord } from "@stim-cli/core/state";
+import { StringDecoder } from "node:string_decoder";
+//#region src/macos/run.ts
+function logLines(stream, write) {
+	const decoder = new StringDecoder("utf8");
+	let pending = "";
+	stream.on("data", (chunk) => {
+		pending += decoder.write(chunk);
+		while (pending.length > 65536 && !pending.includes("\n")) {
+			write(pending.slice(0, 65536));
+			pending = pending.slice(65536);
+		}
+		const lines = pending.split("\n");
+		pending = lines.pop() ?? "";
+		for (const line of lines) write(line.replace(/\r$/, ""));
+	});
+	stream.on("end", () => {
+		pending += decoder.end();
+		if (pending) write(pending);
+	});
+}
+async function runMacosSupervisor(root, launchId) {
+	const record = readMacosRecord(root);
+	if (!record || record.launchId !== launchId || record.build.state !== "ok") throw new Error("The macOS launch record changed before its supervisor started.");
+	const owner = macosProcess(process.pid);
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: macosRuntimeClaim(root),
+		mode: "exclusive",
+		label: "macOS app"
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new Error(`The macOS runtime is already held at ${attempt.held?.path ?? macosRuntimeClaim(root)}.`);
+	const writer = createNdjsonWriter(macosLogFile(root), { maxBytes: LOG_ROTATE_BYTES });
+	let app;
+	let stopping = false;
+	let spawned = false;
+	let childExited = false;
+	try {
+		if (!(0, process_identity_exports.sameProcessRecord)(readMacosRecord(root)?.supervisor, record.supervisor) || !updateMacosRecord(root, record.supervisor, { supervisor: owner })) throw new Error("The macOS launch owner changed.");
+		(0, ownership_claim_exports.markClaimChildPending)(claim);
+		const child = getExecutor().spawn(record.executable, record.arguments, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				NSUnbufferedIO: "YES"
+			}
+		});
+		spawned = child.pid !== void 0;
+		const ended = new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("close", () => {
+				childExited = true;
+				resolve();
+			});
+		});
+		if (!child.pid) {
+			await ended;
+			throw new Error("The macOS app did not start.");
+		}
+		app = macosProcess(child.pid);
+		(0, ownership_claim_exports.setClaimChild)(claim, app);
+		if (!updateMacosRecord(root, owner, { app })) {
+			if ((0, process_identity_exports.inspectProcessIdentity)(app) === "same") process.kill(app.pid, "SIGTERM");
+			throw new Error("The macOS launch owner changed.");
+		}
+		const log = (level, msg) => writer.write({
+			src: "client",
+			platform: "macos",
+			level,
+			msg
+		});
+		if (child.stdout) logLines(child.stdout, (line) => log("info", line));
+		if (child.stderr) logLines(child.stderr, (line) => log("warn", line));
+		const stop = async () => {
+			if (stopping) return;
+			stopping = true;
+			for (const signal of ["SIGTERM", "SIGKILL"]) {
+				if (!app || (0, process_identity_exports.inspectProcessIdentity)(app) !== "same") return;
+				process.kill(app.pid, signal);
+				if (await (0, process_identity_exports.waitForProcessExit)(app, 5e3)) return;
+			}
+		};
+		process.on("SIGTERM", stop);
+		process.on("SIGINT", stop);
+		log("info", `Started ${record.product} (pid ${app.pid}).`);
+		await ended;
+		process.off("SIGTERM", stop);
+		process.off("SIGINT", stop);
+		log(stopping || child.exitCode === 0 ? "info" : "error", `Exited ${record.product} (${child.exitCode ?? child.signalCode ?? "unknown"}).`);
+		updateMacosRecord(root, owner, {
+			app: void 0,
+			supervisor: void 0
+		});
+	} finally {
+		if (!spawned || childExited || app && ["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(app))) {
+			(0, ownership_claim_exports.clearClaimChild)(claim);
+			(0, ownership_claim_exports.releaseClaim)(claim);
+		}
+		writer.close();
+	}
+}
+if (process.argv[1]?.endsWith("/macos-run.mjs") || process.argv[1]?.endsWith("/macos/run.ts")) {
+	const [root, launchId] = process.argv.slice(2);
+	if (!root || !launchId) throw new Error("macos-run needs a workspace and launch identity.");
+	await runMacosSupervisor(root, launchId);
+}
+//#endregion
+export { runMacosSupervisor as n, logLines as t };

package/dist/{server-bare-DGfgyJ5J.mjs → server-bare-CpPGmnmO.mjs}

@@ -1,8 +1,8 @@
 import { i as __require, t as __commonJSMin } from "./rolldown-runtime-BsOwBuO_.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { D as projectMetroSharedCache } from "./settings-oTSkkNrM.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { w as projectMetroSharedCache } from "./settings-D61iNOsB.mjs";
-import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-DzeWkfqW.mjs";
+import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-CDDZHtPl.mjs";
 import { createRequire } from "node:module";
 import { isAbsolute, join, relative, sep } from "node:path";
 //#endregion
@@ -14,6 +14,8 @@ var import_bundle_response = (/* @__PURE__ */ __commonJSMin(((exports, module) =
 		"::1",
 		"::ffff:127.0.0.1"
 	]);
+	const PROGRESS_PART = /^\{"done":(\d+),"total":(\d+),"percent":(\d+)\}$/;
+	const PROGRESS_INTERVAL_MS = 1e3;
 	function clientPidFromLsof(output, clientPort, serverPort) {
 		const connection = new RegExp(`:${clientPort}->\\S*:${serverPort}$`);
 		let pid = null;
@@ -36,7 +38,7 @@ var import_bundle_response = (/* @__PURE__ */ __commonJSMin(((exports, module) =
 				res.end("ready");
 				return;
 			}
-			if (req.headers["x-stim-metro-warmup"] === "1") return next();
+			const prefetch = req.headers["x-stim-metro-warmup"] === "1";
 			let url;
 			try {
 				url = new URL(req.url, "http://localhost");
@@ -46,34 +48,50 @@ var import_bundle_response = (/* @__PURE__ */ __commonJSMin(((exports, module) =
 			const platform = url.searchParams.get("platform");
 			if (req.method !== "GET" || !/\.bundle\/*$/.test(url.pathname) || !["ios", "android"].includes(platform)) return next();
 			const requestId = randomUUID();
-			const clientPid = platform === "ios" ? lookupClientPid(req, runLsof) : null;
-			const send = (ts, event, statusCode, pid) => {
+			const kind = prefetch ? "prefetch" : "response";
+			const clientPid = platform === "ios" && !prefetch ? lookupClientPid(req, runLsof) : null;
+			const send = (ts, stage, statusCode, pid, progress) => {
 				try {
 					write({
 						ts,
 						src: "metro",
-						level: event === "bundle_response_failed" ? "error" : "debug",
-						event,
+						level: stage === "failed" && !prefetch ? "error" : "debug",
+						event: `bundle_${kind}_${stage}`,
 						platform,
 						requestId,
-						statusCode,
-						msg: `${platform} bundle response ${event.slice(16)}`,
+						...progress ?? { statusCode },
+						msg: progress ? `${platform} bundle ${progress.percent}%` : `${platform} bundle ${kind} ${stage}`,
 						...pid ? { clientPid: pid } : {}
 					});
 				} catch {}
 			};
-			const emit = (event, statusCode) => {
+			const emit = (stage, statusCode, progress) => {
 				const ts = Date.now();
-				if (clientPid) clientPid.then((pid) => send(ts, event, statusCode, pid));
-				else send(ts, event, statusCode, null);
+				if (clientPid) clientPid.then((pid) => send(ts, stage, statusCode, pid, progress));
+				else send(ts, stage, statusCode, null, progress);
+			};
+			emit("started");
+			const writeChunk = res.write;
+			let progressAt = 0;
+			res.write = function(chunk, ...rest) {
+				const part = typeof chunk === "string" && chunk.length < 100 ? PROGRESS_PART.exec(chunk) : null;
+				const now = part ? Date.now() : 0;
+				if (part && now - progressAt >= PROGRESS_INTERVAL_MS) {
+					progressAt = now;
+					emit("progress", void 0, {
+						done: Number(part[1]),
+						total: Number(part[2]),
+						percent: Number(part[3])
+					});
+				}
+				return writeChunk.call(this, chunk, ...rest);
 			};
-			emit("bundle_response_started");
 			let ended = false;
 			const finish = (complete) => {
 				if (ended) return;
 				ended = true;
 				const success = complete && (res.statusCode === 200 || res.statusCode === 304);
-				emit(success ? "bundle_response_finished" : "bundle_response_failed", res.statusCode);
+				emit(success ? "finished" : "failed", res.statusCode);
 			};
 			res.once("finish", () => finish(true));
 			res.once("close", () => finish(false));

package/dist/server-expo-CVqO2c35.mjs

@@ -0,0 +1,2 @@
+import { p as startExpoServer } from "./server-expo-MC0rHlOC.mjs";
+export { startExpoServer };

package/dist/{server-expo-BVuwQ65v.mjs → server-expo-MC0rHlOC.mjs}

@@ -1,13 +1,13 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { f as resolvePackageJson } from "./project-CWlvEaeN.mjs";
-import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { n as stripAnsi, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { w as projectMetroSharedCache } from "./settings-D61iNOsB.mjs";
-import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-DzeWkfqW.mjs";
+import { D as projectMetroSharedCache } from "./settings-oTSkkNrM.mjs";
+import { p as resolvePackageJson } from "./project-Du91Ilvc.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-CDDZHtPl.mjs";
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { dirname, join, parse } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 //#region src/supervisor/server-expo.ts
 function delay(ms) {
 	return new Promise((resolve) => {
@@ -120,11 +120,7 @@ function recordFromLine(line, { stream = "stdout" } = {}) {
 	if (!msg.trim()) return null;
 	if (stream === "stderr" && msg.startsWith("stim-bundle-response: ")) try {
 		const record = JSON.parse(msg.slice(22));
-		if (record.src === "metro" && [
-			"bundle_response_started",
-			"bundle_response_finished",
-			"bundle_response_failed"
-		].includes(record.event) && ["ios", "android"].includes(record.platform) && typeof record.requestId === "string" && Number.isFinite(record.ts)) return record;
+		if (record.src === "metro" && /^bundle_(response|prefetch)_(started|progress|finished|failed)$/.test(record.event) && ["ios", "android"].includes(record.platform) && typeof record.requestId === "string" && Number.isFinite(record.ts)) return record;
 	} catch {}
 	const confirmed = metroStoreConfirmedRoot(msg);
 	if (confirmed) return {

package/dist/settings-BBpMcDbD.mjs

@@ -0,0 +1,25 @@
+import { SETTINGS, coerceSettingText, loadConfig, settingValueError } from "@stim-cli/core/state";
+//#region src/maintenance/settings.ts
+function resolveMaintenanceSettings(config = loadConfig(), env = process.env) {
+	const result = {};
+	const invalid = [];
+	let disabled = false;
+	for (const setting of SETTINGS.filter((entry) => entry.key.startsWith("maintenance.") || /^caches\..*MaxGb$/.test(entry.key))) {
+		const [group, name] = setting.key.split(".");
+		const rawEnv = setting.env ? env[setting.env] : void 0;
+		const layer = config?.[group];
+		const configured = layer && typeof layer === "object" ? layer[name] : void 0;
+		const value = rawEnv !== void 0 ? coerceSettingText(setting, rawEnv) : env.STIM_HOME && setting.scopedHomeValue !== void 0 ? setting.scopedHomeValue : env.CI && setting.ciValue !== void 0 ? setting.ciValue : configured === void 0 ? setting.default : configured;
+		const error = value === void 0 ? null : settingValueError(setting, value);
+		if (error) {
+			invalid.push(`${setting.key}: expected ${error}`);
+			if (group === "maintenance") disabled = true;
+		}
+		result[name] = error ? setting.default : value;
+	}
+	if (disabled) result.mode = "off";
+	if (invalid.length) result.invalid = invalid.join("; ");
+	return result;
+}
+//#endregion
+export { resolveMaintenanceSettings as t };

package/dist/{settings-B-fsC-Om.mjs → settings-ZkDzkzvB.mjs}

@@ -1,11 +1,11 @@
-import { D as writeConfigSetting, E as withConfigLock$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-lvc7d3C2.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-BVrHsYZG.mjs";
-import { i as findCommandWorkspace, t as NO_PROJECT_REFUSAL } from "./project-CWlvEaeN.mjs";
-import { n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-CXt8-Z3J.mjs";
-import { D as readCommittedSettings, L as unknownSettingKeys } from "./settings-D61iNOsB.mjs";
+import { D as withConfigLock$1, O as writeConfigSetting, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-D0DbpZtM.mjs";
+import { A as readCommittedSettings, H as unknownSettingKeys, gt as repoRoot, it as gitCommonDir } from "./settings-oTSkkNrM.mjs";
+import { a as findCommandWorkspace, t as NO_PROJECT_REFUSAL } from "./project-Du91Ilvc.mjs";
+import { n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-Cnz8CPnl.mjs";
+import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-BIXOzVnr.mjs";
 import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, settingDefinition, settingValueError } from "@stim-cli/core/state";
 import { join } from "node:path";
+import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, settingDefinition, settingValueError } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/settings.ts
 const MASK = "********";
@@ -85,6 +85,7 @@ function settingEntry(context, setting) {
 		value: String(masked(setting, envValue))
 	} : void 0;
 	const scopedHome = !env && setting.scopedHomeValue !== void 0 && context.env.STIM_HOME;
+	const ci = !env && setting.ciValue !== void 0 && context.env.CI;
 	const winner = PRECEDENCE.find((scope) => scope in layers);
 	let value = null;
 	let origin = null;
@@ -95,6 +96,9 @@ function settingEntry(context, setting) {
 	} else if (scopedHome) {
 		value = setting.scopedHomeValue;
 		origin = "env";
+	} else if (ci) {
+		value = setting.ciValue;
+		origin = "env";
 	} else if (winner) {
 		value = layers[winner];
 		origin = winner;
@@ -112,6 +116,9 @@ function settingEntry(context, setting) {
 		...env ? { env } : scopedHome ? { env: {
 			name: "STIM_HOME",
 			value: context.env.STIM_HOME
+		} } : ci ? { env: {
+			name: "CI",
+			value: context.env.CI
 		} } : {},
 		...setting.sensitive ? { sensitive: true } : {},
 		...defaultReason ? { defaultReason } : {}
@@ -344,37 +351,42 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 		if (setting.sensitive && scope === "committed" && !isSensitiveReference(value)) throw new Refusal("STIM_BAD_ARG", `${key} is sensitive, so a committed .stim.json takes only an env: or file: reference, never the secret.`, `Set the secret with --scope workspace or --scope repo, or commit a reference such as env:MY_KEYSTORE_PASSWORD.`);
 		const context = readContext(env, io.note);
 		const file = requireLayer(context, scope, setting);
+		const recording = setting.key === "recording.enabled" ? recordingLayers() : null;
 		const changed = writeSetting(context, setting, scope, value);
 		report(io, wantsJson(opts, command), {
 			key,
 			scope,
 			file,
 			changed
-		}, setting, readContext(env), "set");
+		}, setting, readContext(env), "set", recording);
 	}));
 	settings.command("unset <key>").description("Remove a setting from one layer").option("--scope <scope>", `the layer to clear: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the setting after removal as JSON").action((key, opts, command) => run(wantsJson(opts, command), io, () => {
 		const setting = requireSetting(key);
 		const scope = readScope(opts.scope, setting);
 		const context = readContext(env, io.note);
 		const file = requireLayer(context, scope, setting);
+		const recording = setting.key === "recording.enabled" ? recordingLayers() : null;
 		const changed = writeSetting(context, setting, scope, void 0);
 		report(io, wantsJson(opts, command), {
 			key,
 			scope,
 			file,
 			changed
-		}, setting, readContext(env), "unset");
+		}, setting, readContext(env), "unset", recording);
 	}));
 }
-function report(io, json, write, setting, context, verb) {
+function report(io, json, write, setting, context, verb, recordingBefore) {
 	const entry = settingEntry(context, setting);
+	const recordingsDeleted = recordingBefore ? deleteTurnedOffRecordings(recordingBefore) : null;
 	if (json) {
 		io.out(JSON.stringify({
 			...write,
-			setting: entry
+			setting: entry,
+			...recordingsDeleted ? { recordingsDeleted } : {}
 		}));
 		return;
 	}
+	for (const workspace of recordingsDeleted ?? []) io.note(`Deleted the device recordings of ${workspace}.`);
 	const effective = entry.origin === null ? "unset" : `${formatValue(entry.value)} (${formatOrigin(entry)})`;
 	if (!write.changed) {
 		io.out(`${write.key} was not set in ${write.file}; effective value: ${effective}`);