stim 1.19.0 → 1.20.0

package/dist/build-plan-CP0tckNU.mjs

@@ -0,0 +1,553 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { _ as loadConfig$1, p as getProject } from "./config-D0LhTY3S.mjs";
+import { Ft as removeTemporaryEntry, Pt as makeTemporaryDirectory, at as detectProviders, ot as planMetroReach } from "./settings-Bbztm4oV.mjs";
+import { w as entryDir, y as artifactIn } from "./device-lease-DHOBXGgS.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-BjPN99ZB.mjs";
+import { N as readRemoteSession, j as readMetroTunnel } from "./project-B8_duAzW.mjs";
+import { Mt as readStats$1, s as peekBudget, wt as estimateBuild } from "./budget-BONq9vXY.mjs";
+import { a as easAuthNote, f as resolveEasCliBin, s as isEasAuthFailureText } from "./remote-cache-Bsts6f6Y.mjs";
+import { S as hostingMachines, h as namedBuildMachine, v as resolveBuildMachine } from "./client-BLy1Pw2V.mjs";
+import { P as readHostMemoryPressure } from "./ios-CXLIUxXJ.mjs";
+import { r as predictBuildMiss } from "./miss-reason-BPAzZS0r.mjs";
+import { s as peekDeviceSlots } from "./device-capacity-Ca_ke1LE.mjs";
+import { d as requireHostedAppMode, o as call, s as connectHost } from "./hosted-client-Io01s5By.mjs";
+import { r as readHostedNative, s as writeHostedNative } from "./ios-state-CjrL2qv-.mjs";
+import { n as prepareHostedNative } from "./hosted-native-BdAQi21M.mjs";
+import { h as easCliSupport, m as MIN_EAS_CLI_SIMULATOR_VERSION, p as MIN_EAS_CLI_DEVICE_VERSION, s as readInstalledEasCliVersion } from "./device-remote-Bmg42063.mjs";
+import { i as staleNativeDirRefusal } from "./prebuild-Bw44QxVh.mjs";
+import { automaticMachineEnabled, isJsonObject, machineCapacity, parseHostedChoice, parseHostedNativeOffer } from "@stim-cli/core/state";
+import { resolveTieredBuild } from "@stim-cli/cache";
+import chalk from "chalk";
+//#region src/device-host/placement.ts
+function local$1(code, reason, skipped = [], atCapacity = false) {
+	return {
+		kind: "local",
+		code,
+		reason,
+		skipped,
+		...atCapacity ? { atCapacity: true } : {}
+	};
+}
+function decideDevicePlacement(inputs) {
+	if ("sticky" in inputs) {
+		if ("machine" in inputs.sticky) {
+			const reason = `recorded session on ${inputs.sticky.machine}`;
+			return {
+				kind: "host",
+				code: "sticky",
+				reason,
+				machines: [{
+					machine: inputs.sticky.machine,
+					reason
+				}],
+				skipped: []
+			};
+		}
+		return {
+			kind: "local",
+			code: "sticky",
+			reason: "this workspace's device runs here",
+			skipped: []
+		};
+	}
+	const { platform, here, offers, buildMachine, noWait, eas } = inputs;
+	const { count, max, queued } = here.devices;
+	const room = max === 0 || count !== null && count < max;
+	const localEnabled = here.localEnabled !== false;
+	const cannotTake = !localEnabled || !room || queued > 0;
+	const atCapacity = count !== null && (!room || queued > 0);
+	const usage = max > 0 ? `${count} of ${max} devices in use` : `${count} devices in use, no device cap`;
+	const localReason = !localEnabled ? "local is disabled in remote.devicePoolDisabled" : count === null ? "cannot tell how many devices run here; local boot admission decides" : cannotTake ? `${usage}${queued ? `, ${queued} runs queued ahead` : ""}` : here.budgetRefusal ?? (here.memoryPressure !== "normal" ? `host memory pressure ${here.memoryPressure ?? "unknown"} here` : `load ${here.loadPerCore.toFixed(1)}/core here, ${usage}`);
+	const nowhere = (code, reason, skipped = [], waiting = "") => {
+		if (!localEnabled && !atCapacity) return {
+			kind: "refused",
+			code: "pool-unavailable",
+			reason,
+			skipped
+		};
+		if (!cannotTake || count === null) return local$1(code, reason + waiting, skipped);
+		if (eas?.usable) return {
+			kind: "eas",
+			code: "eas-fallback",
+			reason: `${reason}; EAS Simulator (remote.easFallback)`,
+			skipped
+		};
+		const why = eas ? [...skipped, {
+			machine: "eas",
+			code: eas.code,
+			reason: eas.reason
+		}] : skipped;
+		return localEnabled ? local$1(code, reason + waiting, why, true) : {
+			kind: "refused",
+			code: "pool-unavailable",
+			reason,
+			skipped: why,
+			atCapacity: true
+		};
+	};
+	if (!offers.length) return nowhere("no-remote-mac", "no remote Macs configured; " + localReason);
+	if (localEnabled && count === null) return local$1("device-count-unknown", localReason);
+	if (!cannotTake && here.memoryPressure === "normal" && !here.budgetRefusal && here.loadPerCore < here.maxLoadPerCore) return local$1("this-mac-free", localReason);
+	const skipped = [];
+	const admitted = [];
+	offers.forEach((probe, index) => {
+		let reason = null;
+		let code = "unreachable";
+		if ("failure" in probe) reason = probe.failure;
+		else {
+			const { offer } = probe;
+			if (offer.declined !== null) [code, reason] = ["declined", `declined: ${offer.declined}`];
+			else if (offer.platform !== platform || !offer.choice) [code, reason] = ["no-matching-device", `no matching ${platform} device choice`];
+			else if (offer.resources.memoryPressure !== "normal") [code, reason] = ["memory", "host memory pressure unknown or elevated"];
+			else if (offer.capacity.available === 0) [code, reason] = ["no-capacity", "no hosted device capacity available"];
+			else if (!cannotTake && (offer.resources.loadPerCore === null || offer.resources.loadPerCore >= here.loadPerCore)) [code, reason] = ["load", offer.resources.loadPerCore === null ? "host load unknown while this Mac has room" : "host is not less loaded than this Mac"];
+			else admitted.push({
+				machine: probe.machine,
+				offer,
+				index
+			});
+		}
+		if (reason) skipped.push({
+			machine: probe.machine,
+			code,
+			reason
+		});
+	});
+	admitted.sort((a, b) => Number(b.machine === buildMachine) - Number(a.machine === buildMachine) || (a.offer.resources.loadPerCore ?? Infinity) - (b.offer.resources.loadPerCore ?? Infinity) || b.offer.resources.memoryFreeBytes - a.offer.resources.memoryFreeBytes || a.index - b.index);
+	if (!admitted.length) return nowhere("no-host-admits", `${localReason}; no host admits`, skipped, localEnabled && cannotTake && !noWait ? "; waiting locally if needed" : "");
+	const machines = admitted.map(({ machine, offer }) => ({
+		machine,
+		reason: `${localReason}; ${machine}${machine === buildMachine ? " is the explicit remote Mac," : ""} load ${offer.resources.loadPerCore === null ? "unknown" : offer.resources.loadPerCore.toFixed(1) + "/core"}`
+	}));
+	return {
+		kind: "host",
+		code: "placed",
+		machines,
+		reason: machines[0].reason,
+		skipped
+	};
+}
+//#endregion
+//#region src/device-host/auto-placement.ts
+async function probeHost(machine, platform, selectors, appMode) {
+	let host;
+	const deadline = Date.now() + 3e3;
+	try {
+		host = await connectHost(machine, 3e3, true);
+		requireHostedAppMode(host, platform, appMode);
+		const offer = await call(host, "device-host.offer", {
+			platform,
+			...selectors
+		}, Math.max(1, deadline - Date.now()));
+		const resources = isJsonObject(offer.resources) ? offer.resources : {};
+		const parsed = parseHostedNativeOffer({
+			...offer,
+			resources: {
+				...resources,
+				loadPerCore: resources.loadPerCore ?? 0
+			}
+		});
+		let choice = platform === "ios" ? offer.platform === "ios" ? parseHostedChoice(offer.choice) : null : parsed?.platform === "android" ? parsed.choice : null;
+		if (choice && ("runtime" in choice ? selectors.deviceType && selectors.deviceType !== choice.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== choice.runtime.replace(/^iOS /, "") : selectors.systemImage && selectors.systemImage !== choice.systemImage || selectors.deviceProfile && selectors.deviceProfile !== choice.deviceProfile)) choice = null;
+		if (!isJsonObject(offer.capacity) || offer.declined !== null && typeof offer.declined !== "string") throw new Error("unreadable device offer");
+		return {
+			probe: {
+				machine,
+				offer: {
+					platform,
+					choice,
+					declined: offer.declined,
+					capacity: { available: typeof offer.capacity.available === "number" ? offer.capacity.available : null },
+					resources: {
+						loadPerCore: typeof resources.loadPerCore === "number" && Number.isFinite(resources.loadPerCore) && resources.loadPerCore >= 0 ? resources.loadPerCore : null,
+						memoryFreeBytes: typeof resources.memoryFreeBytes === "number" ? resources.memoryFreeBytes : 0,
+						memoryPressure: typeof resources.memoryPressure === "string" ? resources.memoryPressure : null
+					}
+				}
+			},
+			...choice ? { target: {
+				host,
+				choice,
+				session: null
+			} } : {}
+		};
+	} catch (error) {
+		return { probe: {
+			machine,
+			failure: error instanceof Error ? error.message : String(error)
+		} };
+	} finally {
+		host?.connection.close();
+	}
+}
+function hosted(target, code, reason, skipped = []) {
+	target.selection = {
+		selected: "auto",
+		reason
+	};
+	return {
+		target,
+		placement: {
+			decision: "hosted",
+			machine: target.host.machine,
+			reason
+		},
+		code,
+		skipped
+	};
+}
+function local(code, reason, skipped = []) {
+	return {
+		target: null,
+		placement: {
+			decision: "local",
+			reason
+		},
+		code,
+		skipped
+	};
+}
+function viaEas(code, reason, skipped) {
+	return {
+		target: null,
+		placement: {
+			decision: "eas",
+			machine: "eas",
+			reason
+		},
+		code,
+		skipped
+	};
+}
+async function automaticDevicePlacement({ root, slot, platform, selectors, appMode, buildMachine, noWait, eas }, { machines = hostingMachines, read = readHostedNative, write = writeHostedNative, resume = prepareHostedNative, peek = () => peekDeviceSlots({
+	platform,
+	project: getProject(root),
+	slot
+}), capacity = machineCapacity, memory = readHostMemoryPressure, probe = probeHost, budget = peekBudget } = {}) {
+	const recorded = read(root, platform, slot)[slot];
+	if (recorded) {
+		const target = await resume(recorded.machine, selectors, recorded, platform, true, appMode);
+		if (target) return {
+			target,
+			placement: {
+				decision: "hosted",
+				machine: recorded.machine,
+				reason: recorded.reason ?? decideDevicePlacement({ sticky: { machine: recorded.machine } }).reason
+			},
+			code: "sticky",
+			skipped: [],
+			sticky: true
+		};
+		write(root, slot, null, platform);
+	}
+	const devices = peek();
+	if (devices.localLive) return {
+		...local("sticky", decideDevicePlacement({ sticky: { local: true } }).reason),
+		sticky: true
+	};
+	const configured = machines();
+	if (configured === null) throw Object.assign(/* @__PURE__ */ new Error("remote.machines is invalid. Run stim guide settings and correct it."), { code: "STIM_HOSTING_REFUSED" });
+	const config = loadConfig$1();
+	const entries = configured.filter((machine) => automaticMachineEnabled("device", machine, config));
+	const preference = resolveBuildMachine(buildMachine, process.env.STIM_REMOTE_BUILD, config?.remote?.build);
+	buildMachine = namedBuildMachine(preference) ? preference : void 0;
+	const load = capacity();
+	const here = {
+		localEnabled: automaticMachineEnabled("device", "local", config),
+		loadPerCore: load.loadPerCore,
+		maxLoadPerCore: load.maxLoadPerCore,
+		memoryPressure: memory(),
+		devices,
+		budgetRefusal: await budget(root)
+	};
+	const inputs = (offers) => ({
+		platform,
+		here,
+		offers,
+		buildMachine,
+		noWait
+	});
+	const notProbed = entries.map((machine) => ({
+		machine,
+		failure: "not probed"
+	}));
+	const early = decideDevicePlacement(inputs(notProbed));
+	const probes = early.kind === "local" && early.skipped.length === 0 ? [] : await Promise.all(entries.map((machine) => probe(machine, platform, selectors, appMode)));
+	const offers = probes.length ? probes.map((each) => each.probe) : notProbed;
+	let decision = decideDevicePlacement(inputs(offers));
+	if ((decision.kind === "local" || decision.kind === "refused") && decision.atCapacity && eas) decision = decideDevicePlacement({
+		...inputs(offers),
+		eas: await eas()
+	});
+	if (decision.kind === "refused") throw Object.assign(new Error(devicePlacementLine({
+		decision: "local",
+		reason: decision.reason
+	}, decision.skipped)), {
+		code: "STIM_HOSTING_REFUSED",
+		remedy: "Enable an available member in remote.devicePoolDisabled or select a machine explicitly."
+	});
+	if (decision.kind === "eas") return viaEas(decision.code, decision.reason, decision.skipped);
+	if (decision.kind === "local") return local(decision.code, decision.reason, decision.skipped);
+	const target = probes.find((each) => each.probe.machine === decision.machines[0].machine).target;
+	return hosted(target, decision.code, decision.reason, decision.skipped);
+}
+function devicePlacementLine(placement, skipped) {
+	return `${placement.machine ?? "local"}, ${placement.reason}${placement.decision !== "hosted" && skipped.length ? "; " + skipped.map((each) => `${each.machine}: ${each.reason}`).join("; ") : ""}`;
+}
+//#endregion
+//#region src/engine/eas-fallback.ts
+const AVAILABILITY_TIMEOUT_MS = 3e4;
+function unusable(code, reason) {
+	return {
+		usable: false,
+		code,
+		reason
+	};
+}
+/** Reads `eas simulator:availability --json`: `{"available": true, ...}` on stdout, or a failure on stderr. */
+function parseSimulatorAvailability(outcome) {
+	if ("failure" in outcome) {
+		if (outcome.timedOut) return unusable("eas-unavailable", "eas simulator:availability timed out");
+		const detail = outcome.failure.split("\n").map((line) => line.trim()).find((line) => line && !/is now available\.$|^(To upgrade|npm install|Proceeding with|\(node:|\(Use `node)/.test(line));
+		if (isEasAuthFailureText(outcome.failure)) return unusable("eas-logged-out", "eas-cli is not logged in (run eas login or set EXPO_TOKEN)");
+		return unusable("eas-unavailable", `eas simulator:availability failed${detail ? `: ${detail}` : ""}`);
+	}
+	let data = null;
+	try {
+		data = JSON.parse(outcome.stdout.slice(outcome.stdout.indexOf("{")));
+	} catch {}
+	if (typeof data !== "object" || data === null || typeof data.available !== "boolean") return unusable("eas-unavailable", "eas simulator:availability printed no availability");
+	return data.available ? { usable: true } : unusable("eas-not-enabled", "EAS Simulator is not enabled for this EAS account");
+}
+/**
+* Whether this run could use an EAS Simulator the way `--remote eas` does, without starting a session or a build.
+* Each refusal names what `--remote eas` would refuse later, so automatic placement falls through instead.
+*/
+async function checkEasFallback({ root, platform, slot, release, isExpo, tunnelMode, publicUrl, deviceTypeFlag, localOnlyFlags, env = process.env, resolveBin = resolveEasCliBin, readVersion = readInstalledEasCliVersion, onPath = (bin) => getExecutor().findExecutable(bin) !== null, readTunnel = readMetroTunnel, readSession = readRemoteSession, metroPort = () => getProject(root)?.metroPort ?? null, availability = async (bin) => {
+	try {
+		return { stdout: await getExecutor().runFileAsync(bin, [
+			"simulator:availability",
+			"--json",
+			"--non-interactive"
+		], {
+			cwd: root,
+			timeoutMs: AVAILABILITY_TIMEOUT_MS
+		}) };
+	} catch (error) {
+		const err = error;
+		return {
+			failure: String(err.stderr || err.message || error),
+			timedOut: err.code === "ETIMEDOUT"
+		};
+	}
+} }) {
+	if (slot !== "default") return unusable("eas-named-slot", `an EAS Simulator takes only the default slot, not ${slot}`);
+	if (localOnlyFlags.length) return unusable("eas-local-flags", `${localOnlyFlags.join(" and ")} applies only to a ${platform} device on a Mac`);
+	const session = readSession(root);
+	if (session && session.platform !== platform) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.platform ?? "another platform"}`);
+	if (session && deviceTypeFlag?.trim() && session.deviceType !== deviceTypeFlag.trim()) return unusable("eas-session-busy", `this workspace's EAS Simulator session ${session.sessionId} runs ${session.deviceType ?? "the model EAS chose"}, not ${deviceTypeFlag.trim()}`);
+	if (!onPath("agent-device")) return unusable("eas-no-agent-device", "agent-device is not on PATH");
+	const bin = resolveBin(root);
+	if (!bin) return unusable("eas-no-cli", "eas-cli is not installed for this project or on PATH");
+	const versionOutput = readVersion(bin.file, root);
+	const minimum = platform === "ios" && deviceTypeFlag?.trim() ? MIN_EAS_CLI_DEVICE_VERSION : MIN_EAS_CLI_SIMULATOR_VERSION;
+	const { supported, version } = easCliSupport(versionOutput, minimum);
+	if (!supported) return unusable("eas-cli-too-old", `eas-cli ${version ?? "(unknown version)"} is older than ${minimum}`);
+	if (!release) {
+		const mode = tunnelMode ?? "auto";
+		if (mode === "off") return unusable("eas-metro-unreachable", "metro.tunnel is off, so an EAS Simulator cannot reach Metro");
+		const plan = planMetroReach({
+			mode,
+			metroPort: metroPort() ?? "unknown",
+			publicUrl: env["STIM_METRO_PUBLIC_URL"]?.trim() || publicUrl,
+			isExpo,
+			available: detectProviders(onPath, mode)
+		});
+		if ("failed" in plan) return unusable("eas-metro-unreachable", plan.failed);
+		if ("start" in plan && plan.start === "tailscale") return unusable("eas-metro-unreachable", "metro.tunnel is tailscale, which an EAS Simulator cannot reach");
+		if ("expoTunnel" in plan && readTunnel(root)?.kind !== "expo") return unusable("eas-metro-unreachable", "Metro has no Expo tunnel; run stim start --remote first");
+	}
+	return parseSimulatorAvailability(await availability(bin.file));
+}
+//#endregion
+//#region src/commands/build-plan.ts
+const DISCARD = {
+	file: "",
+	written: 0,
+	dropped: 0,
+	lastError: null,
+	write: () => true,
+	close: () => ({
+		file: "",
+		written: 0,
+		dropped: 0,
+		lastError: null
+	})
+};
+async function providerHit({ root, platform, cacheKey, providerConfig }, deps) {
+	if (!providerConfig) return null;
+	let destinationDir;
+	try {
+		destinationDir = makeTemporaryDirectory(root, "stim-plan-");
+	} catch (error) {
+		deps.note(chalk.yellow(phaseLine("cache", `provider not checked: ${error?.message || error}`)));
+		return null;
+	}
+	try {
+		const found = await resolveTieredBuild({
+			local: {
+				resolve: () => null,
+				store: () => null
+			},
+			loadProvider: () => deps.loadCacheProvider({
+				projectRoot: root,
+				config: providerConfig
+			}),
+			target: {
+				projectRoot: root,
+				platform,
+				key: cacheKey
+			},
+			destinationDir,
+			warn: (_code, message) => deps.note(chalk.yellow(phaseLine("cache", message)))
+		});
+		return found ? found.providerName ?? "the cache provider" : null;
+	} finally {
+		removeTemporaryEntry(destinationDir);
+	}
+}
+async function expoRemoteHit(lookup, deps) {
+	if (!lookup.expoRemote) return null;
+	const { root, platform, isExpo, fingerprint } = lookup;
+	const loaded = await deps.loadProjectProvider(root, { isExpo });
+	if (loaded?.unavailable) {
+		deps.note(chalk.yellow(phaseLine("cache", `provider not usable: ${loaded.unavailable}`)));
+		return null;
+	}
+	if (!loaded?.provider) return null;
+	const name = loaded.name ?? "the build cache provider";
+	if (name === "eas") {
+		const auth = deps.checkEasAuth({
+			projectRoot: root,
+			owner: loaded.owner || null
+		});
+		const authNote = easAuthNote(auth);
+		if (authNote) deps.note(chalk.yellow(phaseLine("cache", authNote)));
+		if (auth?.code === "logged-out") return null;
+	}
+	const hit = await deps.resolveRemote({
+		provider: loaded.provider,
+		platform,
+		projectRoot: root,
+		fingerprintHash: fingerprint,
+		runOptions: lookup.expoRemote.runOptions,
+		logWriter: DISCARD
+	});
+	if (hit?.timedOut) deps.note(chalk.yellow(phaseLine("cache", `${name} did not answer; counted as a miss`)));
+	else if (hit?.failed) deps.note(chalk.yellow(phaseLine("cache", `${name} could not be used: ${hit.failed}`)));
+	return hit?.appPath ? name : null;
+}
+async function planCachedBuild(lookup, deps) {
+	const { root, platform, isExpo, fingerprint, sources, cacheKey, cachePolicy } = lookup;
+	let cacheHit = false;
+	let provider = null;
+	if (cachePolicy.read) {
+		if (artifactIn(entryDir(platform, cacheKey))) cacheHit = "local";
+		else {
+			provider = (cachePolicy.remote ? await providerHit(lookup, deps) : null) ?? await expoRemoteHit(lookup, deps);
+			if (provider) cacheHit = "remote";
+		}
+	}
+	let prebuild = null;
+	let refusal = null;
+	let missReason;
+	if (!cacheHit) {
+		prebuild = deps.planPrebuild(root, platform, {
+			isExpo,
+			fingerprint,
+			sources
+		});
+		if (prebuild === "refuse") refusal = staleNativeDirRefusal(platform);
+		else if (cachePolicy.read) missReason = predictBuildMiss({
+			root,
+			platform,
+			current: {
+				hash: fingerprint,
+				sources
+			},
+			prebuild: prebuild === "generate" || prebuild === "regenerate" ? prebuild : null
+		});
+	}
+	return planPayload(lookup, {
+		fingerprint,
+		cacheKey,
+		cacheHit,
+		provider,
+		cacheSkipped: !cachePolicy.read,
+		prebuild,
+		...missReason ? { missReason } : {},
+		refusal
+	});
+}
+function planPayload({ platform, slot, projectKey }, found) {
+	const { refusal, missReason, ...rest } = found;
+	const outcome = refusal ? null : found.cacheHit ? "hit" : "cold";
+	const estimate = outcome ? estimateBuild(readStats$1().record?.history?.[projectKey], platform, outcome) : {
+		expectedMs: null,
+		basis: 0
+	};
+	return {
+		platform,
+		...slot === "default" ? {} : { slot },
+		...rest,
+		outcome,
+		expectedMs: estimate.expectedMs,
+		basis: estimate.basis,
+		...missReason ? { missReason } : {},
+		...refusal ? { refusal } : {}
+	};
+}
+function cacheLine(plan) {
+	if (plan.refusal) return `the build would refuse with ${plan.refusal.code}`;
+	if (plan.cacheHit === "local") return "local cache hit";
+	if (plan.cacheHit === "remote") return `remote cache hit (${plan.provider})`;
+	return `${plan.cacheSkipped ? "cache reads are off" : "cache miss"}: compiles${plan.prebuild === "generate" || plan.prebuild === "regenerate" ? `, ${plan.prebuild}s the native dir` : ""}`;
+}
+function printPlan(plan, json) {
+	if (json) {
+		console.log(JSON.stringify(plan));
+		return;
+	}
+	const slot = plan.slot ? ` [${plan.slot}]` : "";
+	console.log(phaseLine("plan", `${plan.platform}${slot} ${shortHash(plan.fingerprint)} -> ${cacheLine(plan)}`));
+	if (plan.placement) console.log(phaseLine("placement", plan.placement));
+	if (plan.missReason) console.log(phaseLine("cache", `miss: ${plan.missReason.summary}`));
+	if (plan.refusal) {
+		console.log(phaseLine("error", plan.refusal.message));
+		console.log(phaseLine("remedy", plan.refusal.remedy));
+		return;
+	}
+	console.log(phaseLine("expect", plan.expectedMs === null ? `unknown: no ${plan.outcome} run of this project is recorded yet` : `~${formatDuration(plan.expectedMs)} (median of ${plural(plan.basis, `${plan.outcome} run`)})`));
+}
+function refusePlan({ code, message, remedy }, json, lines = []) {
+	console.error(chalk.red(phaseLine("error", message)));
+	for (const line of lines) console.error(chalk.dim(phaseLine("", line)));
+	console.error(chalk.dim(phaseLine("remedy", remedy)));
+	console.error(chalk.red(phaseLine("failed", code)));
+	if (json) console.log(JSON.stringify({
+		code,
+		message,
+		remedy
+	}));
+	process.exitCode = 1;
+}
+const PLAN_ONLY_REMEDY = "Drop the flag to plan the owned simulator or emulator build, or run the command without --plan.";
+function planFlagRefusal(flag) {
+	return {
+		code: "STIM_BAD_ARG",
+		message: `${flag} does not apply to --plan, which predicts the next local build without choosing a device.`,
+		remedy: PLAN_ONLY_REMEDY
+	};
+}
+//#endregion
+export { refusePlan as a, devicePlacementLine as c, printPlan as i, probeHost as l, planFlagRefusal as n, checkEasFallback as o, planPayload as r, automaticDevicePlacement as s, planCachedBuild as t };

package/dist/{cache-manifest-DiwKSyv9.mjs → cache-manifest-qA3dT2x2.mjs}

@@ -1,4 +1,4 @@
-import { d as getConfigDir } from "./config-DC5jEtd1.mjs";
+import { d as getConfigDir } from "./config-D0LhTY3S.mjs";
 import { isAbsolute, join, resolve } from "path";
 import { existsSync } from "fs";
 import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";

package/dist/cache-manifest.mjs

@@ -1,2 +1,2 @@
-import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-DiwKSyv9.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-qA3dT2x2.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/{manifest-CX0d1IkZ.mjs → ccache-CjHQ5F8g.mjs}

@@ -1,13 +1,13 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
-import { _ as loadConfig } from "./config-DC5jEtd1.mjs";
-import { f as sharedCcache, x as workspaceLogsDir } from "./workspace-state-CR9X86xJ.mjs";
-import { r as register } from "./cache-manifest-DiwKSyv9.mjs";
-import { o as machineNumber } from "./budget-Dz-kyXLv.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { _ as loadConfig } from "./config-D0LhTY3S.mjs";
+import { r as register } from "./cache-manifest-qA3dT2x2.mjs";
+import { m as defaultAndroidLayout } from "./settings-Bbztm4oV.mjs";
+import { h as sharedCcache, w as workspaceLogsDir } from "./workspace-state-CSIFuuDa.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { o as machineNumber } from "./budget-BONq9vXY.mjs";
 import { readFileSync, realpathSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { isAbsolute, join, relative } from "node:path";
 import chalk from "chalk";
-import { createHash } from "node:crypto";
 const CCACHE_SLOPPINESS = "pch_defines,time_macros";
 const STATS_LOG_FILE = "ccache-stats.log";
 const CCACHE_UNAVAILABLE = {
@@ -106,15 +106,16 @@ function canonical(root) {
 		return root;
 	}
 }
-function resolveCcache({ root, dir = sharedCcache(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
+function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = sharedCcache(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
 	const binary = lookup();
 	if (!binary) {
 		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
 		return null;
 	}
-	const declared = projectCmakeLauncher(readOrNull(join(root, "android", "app", "build.gradle")));
+	const { moduleDir } = layout;
+	const declared = projectCmakeLauncher(readOrNull(join(moduleDir, "build.gradle")) ?? readOrNull(join(moduleDir, "build.gradle.kts")));
 	if (declared) {
-		onNote(chalk.dim(phaseLine("cache", `ccache off (android/app/build.gradle sets ${declared} itself)`)));
+		onNote(chalk.dim(phaseLine("cache", `ccache off (${join(relative(root, moduleDir), "build.gradle")} sets ${declared} itself)`)));
 		return null;
 	}
 	const statsLog = ccacheStatsLog(root);
@@ -138,11 +139,4 @@ function resolveCcache({ root, dir = sharedCcache(), lookup = lookupCcache, onNo
 	};
 }
 //#endregion
-//#region src/offload/manifest.ts
-function manifestDigest(entries) {
-	const hash = createHash("sha256");
-	for (const entry of entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) hash.update(`${entry.path}\0${entry.kind}\0${entry.sha256}\n`);
-	return hash.digest("hex");
-}
-//#endregion
-export { projectCmakeLauncher as a, ccacheActivityLine as i, CCACHE_NOT_RUN as n, readCcacheActivity as o, CCACHE_UNAVAILABLE as r, resolveCcache as s, manifestDigest as t };
+export { readCcacheActivity as a, projectCmakeLauncher as i, CCACHE_UNAVAILABLE as n, resolveCcache as o, ccacheActivityLine as r, CCACHE_NOT_RUN as t };

package/dist/{chrome-BTUOo8p2.mjs → chrome-Dp2lMLBe.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";