stim 1.17.2 → 1.19.0

package/dist/{named-ports-C8m8EQs2.mjs → named-ports-B4iWH4E-.mjs}

@@ -1,9 +1,64 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-DC5jEtd1.mjs";
+import { d as signalProcessTree, f as createPortProbe, o as parseNetstatPids } from "./metro-DI2AjPF_.mjs";
+import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Kqiifsk2.mjs";
 import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+//#region src/engine/workspace-process-lock.ts
+const DEFAULT_WAIT_MS = 6e4;
+const POLL_MS = 25;
+function workspaceProcessLockError(err) {
+	const code = err?.code;
+	if (code === "STIM_LOCK_REFUSED") return "refused";
+	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
+	return null;
+}
+function workspaceProcessLockPath(root, name, external) {
+	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
+}
+async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
+	const deadline = now() + waitMs;
+	for (;;) {
+		signal?.throwIfAborted();
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: path,
+			mode: "exclusive",
+			label: `${name} lock`,
+			details: ownerPurpose ? {
+				...details,
+				purpose: ownerPurpose
+			} : details
+		});
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		if (attempt.acquired) {
+			if (declareSpawns) declareSpawnsOn(attempt.acquired);
+			try {
+				return await fn(attempt.acquired);
+			} finally {
+				stopDeclaringSpawnsOn(attempt.acquired);
+				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+			}
+		}
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		const purpose = holder?.details.purpose;
+		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
+			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
+			error.code = "STIM_LOCK_REFUSED";
+			throw error;
+		}
+		if (holder && onHeld) await onHeld(holder);
+		if (now() >= deadline) {
+			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
+			error.code = "STIM_LOCK_TIMEOUT";
+			throw error;
+		}
+		await sleep(POLL_MS);
+	}
+}
+//#endregion
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;
 const LAST_PORT = 8999;
@@ -14,7 +69,14 @@ function validatePortLabel(label) {
 	if (!/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(label)) throw new Error("A port label must start with a letter and contain at most 64 letters, digits, underscores or hyphens.");
 }
 function portListeners(port, platform) {
-	if (platform === "win32") return listeningPids(port, platform);
+	if (platform === "win32") {
+		const out = getExecutor().runFile("netstat", ["-ano"], {
+			timeoutMs: 5e3,
+			rejectStderr: true
+		});
+		if (!/^\s*(?:Proto|TCP)\s/m.test(out)) throw new Error("netstat printed no TCP connection table.");
+		return parseNetstatPids(out, port);
+	}
 	let out;
 	try {
 		out = getExecutor().runFile("lsof", [
@@ -71,7 +133,7 @@ function releaseBrowserPort(projectPath, port) {
 		saveConfig(cfg);
 	}));
 }
-async function allocateNamedPort(projectPath, label, { isFree = async (port) => await isPortFree(port) && portListeners(port, process.platform).length === 0 }) {
+async function allocateNamedPort(projectPath, label, { isFree = createPortProbe() }) {
 	const root = realpathSync(projectPath);
 	return withPortsLock(async () => {
 		const existing = getProject(root)?.ports;
@@ -165,4 +227,4 @@ async function clearNamedPorts(projectPath, { label, stop = false, dryRun = fals
 	});
 }
 //#endregion
-export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };
+export { withWorkspaceProcessLock as a, reserveBrowserPort as i, getNamedPort as n, workspaceProcessLockError as o, releaseBrowserPort as r, workspaceProcessLockPath as s, clearNamedPorts as t };

package/dist/{native-runtime-BEK171xQ.mjs → native-runtime-BGxsbfny.mjs}

@@ -1,9 +1,9 @@
-import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { x as metroPortSetting } from "./settings-Cfd-0r2d.mjs";
-import { l as resolveProjectMetro } from "./metro-g8NqiJp-.mjs";
-import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-DqcCbpE7.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-lTnWZikR.mjs";
-import { c as startDevServer } from "./start-DUz3mYdb.mjs";
+import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
+import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-CR9X86xJ.mjs";
+import { x as metroPortSetting } from "./settings-CxgngUZk.mjs";
+import { u as resolveProjectMetro } from "./metro-DI2AjPF_.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-DCveSE6d.mjs";
+import { c as startDevServer } from "./start-DtxthMfI.mjs";
 import { readIdleStop } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/native-runtime.ts

package/dist/{ndjson-PclOIwVY.mjs → ndjson-LGZAMsqa.mjs}

@@ -1,7 +1,7 @@
-import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { dirname } from "path";
+import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
+import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { rotateLog } from "@stim-cli/core";
-import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1 } from "@stim-cli/core/state";
 //#region src/ndjson.ts
 const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
@@ -104,9 +104,13 @@ function createNdjsonWriter(file, { truncate = false, fields = {}, maxBytes, now
 }
 function stamp(record) {
 	const base = record && typeof record === "object" && !Array.isArray(record) ? record : { msg: String(record) };
-	if (typeof base.ts === "number" && Number.isFinite(base.ts)) return base;
-	return {
+	const withRun = typeof base.runId === "string" ? base : {
 		...base,
+		runId: runId()
+	};
+	if (typeof base.ts === "number" && Number.isFinite(base.ts)) return withRun;
+	return {
+		...withRun,
 		ts: Date.now()
 	};
 }

package/dist/offload-worker.d.mts

@@ -1,52 +1,10 @@
+import "./state-lKh8shBp.mjs";
+import { a as Optimizations, n as CcacheActivity, r as CompilationCacheActivity } from "./build-facts-B87vo-Im.mjs";
 import "./ndjson-Du3j0AQ9.mjs";
-import "./state-B4PQFXMW.mjs";
-import { readFileSync } from "fs";
 import "@stim-cli/core/state";
+import { readFileSync } from "fs";
 import "@expo/fingerprint";
 import "@stim-cli/core/protocol";
-//#region src/engine/build-facts.d.ts
-interface CompilationCacheActivity {
-  status: "reported" | "unavailable" | "not-run";
-  hits: number | null;
-  cacheableTasks: number | null;
-  hitRatePercent: number | null;
-  swiftTargetsWithoutExplicitModules?: number;
-}
-interface CcacheActivity {
-  status: "reported" | "unavailable" | "not-run";
-  hits: number | null;
-  misses: number | null;
-  hitRatePercent: number | null;
-}
-//#endregion
-//#region src/optimizations.d.ts
-interface Optimizations {
-  buildCache: boolean;
-  remoteBuildCache: boolean;
-  releaseBundleSwap: boolean;
-  metroSharedCache: boolean;
-  metroWarmup: boolean;
-  ios: {
-    compilationCache: boolean;
-    swiftCompilationCache: boolean | null;
-    prefixMapping: boolean;
-  };
-  android: {
-    compilerCache: "ccache" | "cas" | "none";
-    casToolchain: string | null;
-    compilerCacheFallback: CompilerCacheFallback | null;
-    pch: "auto" | "on" | "off";
-    gradleBuildCache: boolean;
-    targetAbiOnly: boolean;
-  };
-}
-interface CompilerCacheFallback {
-  key: string;
-  reason: string;
-  fromEnvironment: boolean;
-  manifest: string | null;
-}
-//#endregion
 //#region src/offload/client.d.ts
 /** The Gradle choices that shape the APK, so the machine builds what this Mac's cache key describes. */
 interface AndroidBuildOptions {

package/dist/offload-worker.mjs

@@ -1,16 +1,16 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { D as fingerprintProject, M as refingerprintAfterMutation } from "./device-lease-DpoS36_u.mjs";
-import { T as CCACHE_UNAVAILABLE, d as buildIos, k as resolveCcache, o as workerToolchain, s as manifestDigest } from "./toolchain-DNyR3NPq.mjs";
-import { t as logLines } from "./run-CkE9y0nc.mjs";
-import { a as runPodInstall, n as podsAreStale, r as readPodState } from "./deps-iKw0eD4P.mjs";
-import { n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-D7RUMkwN.mjs";
-import { a as gradlewPath, i as buildAndroid, r as assembleTaskFor } from "./gradle-dJpre3Yn.mjs";
-import { n as stageBundle, t as resolveBundleExtras } from "./stage-CzaiwFsI.mjs";
-import { d as podAction } from "./support-CsJNVfOc.mjs";
-import { createHash } from "node:crypto";
+import { D as fingerprintProject, M as refingerprintAfterMutation } from "./device-lease-Cu7PtQpZ.mjs";
+import { r as CCACHE_UNAVAILABLE, s as resolveCcache, t as manifestDigest } from "./manifest-CX0d1IkZ.mjs";
+import { c as podsAreStale, f as runPodInstall, l as readPodState, o as workerToolchain } from "./toolchain-C3xSoyUl.mjs";
+import { m as assembleTaskFor, o as buildAndroid, s as buildIos, u as gradlewPath } from "./device-ios-B2ruohE-.mjs";
+import { n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-BKJ3wJI1.mjs";
+import { d as podAction } from "./support-CNqYkV0y.mjs";
+import { r as stageBundle, t as resolveBundleExtras } from "./stage-BgaZJVZY.mjs";
+import { t as logLines } from "./run-lAkle1-c.mjs";
 import { chmodSync, constants, copyFileSync, cpSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { createHash } from "node:crypto";
 //#region src/offload/worker.ts
 function emit(value) {
 	process.stdout.write(`${JSON.stringify(value)}\n`);
@@ -582,7 +582,7 @@ async function compileAndroid(job, root, log, time) {
 }
 async function main() {
 	const mode = process.argv[2];
-	if (mode === "offer") return emit(workerToolchain());
+	if (mode === "offer") return emit(workerToolchain(process.argv[3] ?? null));
 	if (mode === "build") {
 		const chunks = [];
 		for await (const chunk of process.stdin) chunks.push(chunk);

package/dist/{ownership-DyRQru0q.mjs → ownership-EB0ySdGK.mjs}

@@ -1,6 +1,6 @@
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { o as pidExists } from "./metro-g8NqiJp-.mjs";
-import { c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-DqcCbpE7.mjs";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-CR9X86xJ.mjs";
+import { s as pidExists } from "./metro-DI2AjPF_.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {

package/dist/{page-QF_Ke10s.mjs → page-Bv9s2KwY.mjs}

@@ -1,4 +1,4 @@
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
 import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
 //#region src/web/page.ts
 /** The record of a verified live browser: its supervisor and Chrome are the processes the record names. */

package/dist/placement-log-Dxe34rJm.mjs

@@ -0,0 +1,88 @@
+import { T as buildPlacementSettings } from "./client-CuUo8Nvg.mjs";
+//#region src/placement-log.ts
+/** `machine` is `local` when the run stays on this Mac. */
+function placementRecord(input) {
+	const { choice, fallback } = input;
+	const event = input.event ?? (input.kind === "build" ? "build_placement" : "device_placement");
+	const base = `${input.kind} placement: ${choice.machine} (${choice.msg})`;
+	return {
+		src: "placement",
+		level: fallback ? "warn" : "info",
+		...input,
+		event,
+		msg: fallback ? `${base}; fell back: ${fallback.msg}` : base
+	};
+}
+function skippedCandidates(skipped) {
+	return skipped.map(({ machine, code, reason }) => ({
+		machine,
+		code,
+		msg: reason
+	}));
+}
+function devicePlacementRecord({ platform, fromFlag, easFallback = false, placed }) {
+	return placementRecord({
+		kind: "device",
+		platform,
+		settings: [{
+			key: `${platform}.remote`,
+			value: "auto",
+			from: fromFlag ? "flag" : "setting"
+		}, ...easFallback ? [{
+			key: "remote.easFallback",
+			value: "true",
+			from: "setting"
+		}] : []],
+		candidates: skippedCandidates(placed.skipped),
+		choice: {
+			machine: placed.placement.machine ?? "local",
+			code: placed.code,
+			msg: placed.placement.reason
+		}
+	});
+}
+/**
+* The record for where a build runs. `stays` is the reason this Mac builds it, `chose` the remote Mac that takes it,
+* and `fallback` why a remote Mac that was meant to build it did not.
+*/
+function buildPlacementRecord({ platform, buildMachine, candidates = [], ...outcome }) {
+	const base = {
+		kind: "build",
+		platform,
+		settings: buildPlacementSettings(buildMachine),
+		candidates
+	};
+	if ("stays" in outcome) return placementRecord({
+		...base,
+		choice: {
+			machine: "local",
+			code: outcome.stays.code,
+			msg: outcome.stays.reason
+		}
+	});
+	if ("chose" in outcome) return placementRecord({
+		...base,
+		choice: {
+			machine: outcome.chose.machine,
+			code: "placed",
+			msg: outcome.chose.reason
+		}
+	});
+	const { code, reason, machine } = outcome.fallback;
+	return placementRecord({
+		...base,
+		event: outcome.event ?? "build_placement",
+		choice: {
+			machine: "local",
+			code,
+			msg: "building on this Mac"
+		},
+		fallback: {
+			code,
+			msg: reason,
+			...machine ? { machine } : {}
+		}
+	});
+}
+//#endregion
+export { devicePlacementRecord as n, buildPlacementRecord as t };

package/dist/plan-placement-BVY59qa8.mjs

@@ -0,0 +1,290 @@
+import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-Bt8ygHE7.mjs";
+import { Ct as removeTemporaryEntry, St as makeTemporaryDirectory } from "./settings-CxgngUZk.mjs";
+import { B as readStats$1, M as estimateBuild } from "./budget-Dz-kyXLv.mjs";
+import { w as entryDir, y as artifactIn } from "./device-lease-Cu7PtQpZ.mjs";
+import { N as hostingMachines } from "./client-CuUo8Nvg.mjs";
+import { r as readHostedNative } from "./ios-state-By0XuLTQ.mjs";
+import { g as automaticDevicePlacement, r as predictBuildMiss, v as probeHost } from "./miss-reason-CjQCOKqq.mjs";
+import { a as easAuthNote } from "./remote-cache-N3hAEaAL.mjs";
+import { i as staleNativeDirRefusal } from "./prebuild-BKJ3wJI1.mjs";
+import { automaticMachineEnabled } from "@stim-cli/core/state";
+import chalk from "chalk";
+import { resolveTieredBuild } from "@stim-cli/cache";
+//#region src/engine/artifact-lifecycle.ts
+async function runArtifactLifecycle(phases) {
+	try {
+		const resolved = await phases.resolve();
+		if (resolved.kind === "ready") return resolved.artifact;
+		const cached = resolved.kind === "cached" ? resolved.artifact : await phases.claim?.() ?? null;
+		if (cached !== null) {
+			const reused = await phases.reuse(cached);
+			if (reused !== null) return reused;
+		}
+		const { build } = phases;
+		const placement = build.placement?.select() ?? null;
+		if (placement === null) await build.admit();
+		const preparation = await build.prepare();
+		const late = await build.revalidate(preparation);
+		if (late !== null) return late.ready;
+		if (build.placement && placement !== null) {
+			const offloaded = await build.placement.acquire(placement, preparation);
+			if (offloaded !== null) return offloaded.ready;
+			await build.admit();
+		}
+		const artifact = await build.compile(placement, preparation);
+		if (await build.validate(preparation) === "cacheable") await build.store(artifact);
+		return build.finish ? await build.finish(artifact) : artifact;
+	} finally {
+		phases.release();
+	}
+}
+//#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
+//#region src/device-host/plan-placement.ts
+/**
+* Where `--plan` assumes the next run puts its simulator or emulator, with no session, reservation or state write.
+* A named Mac, or the Mac a recorded session already holds, answers with the device its `device-host.offer` would
+* give; `auto` repeats the placement decision a run makes now and, when that stays on this Mac, notes any Mac
+* whose device would key differently. The result predicts the cache key only; a run reads its own device.
+*/
+async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, eas, deps = {} }) {
+	const { automatic = automaticDevicePlacement, probe = probeHost, machines = hostingMachines } = deps;
+	const named = async (name) => {
+		const result = await probe(name, platform, selectors);
+		if ("failure" in result.probe) return {
+			kind: "unknown",
+			reason: `${name} did not give a ${platform} device (${result.probe.failure})`
+		};
+		const { choice, declined } = result.probe.offer;
+		if (!choice) return {
+			kind: "unknown",
+			reason: `${name} has no ${platform} device for this selection${declined ? ` (${declined})` : ""}`
+		};
+		return {
+			kind: "hosted",
+			choice,
+			placement: `on ${name}`
+		};
+	};
+	if (machine !== "auto") return named(machine);
+	try {
+		const recorded = readHostedNative(root, platform, slot)[slot];
+		if (recorded) return await named(recorded.machine);
+		const placed = await automatic({
+			root,
+			slot,
+			platform,
+			selectors,
+			noWait: false,
+			...eas ? { eas } : {}
+		}, {
+			read: () => ({}),
+			write: () => {}
+		});
+		if (placed.placement.decision === "eas") return {
+			kind: "unknown",
+			reason: `auto would run on an EAS Simulator now (${placed.placement.reason}), which --plan cannot read without a session`
+		};
+		if (placed.target) return {
+			kind: "hosted",
+			choice: placed.target.choice,
+			placement: `on ${placed.target.host.machine}, as auto would now`
+		};
+		const names = (machines() ?? []).filter((name) => automaticMachineEnabled("device", name));
+		const differs = (await Promise.all(names.map((name) => probe(name, platform, selectors)))).flatMap(({ probe: each }) => "offer" in each && each.offer.choice && sameKey(each.offer.choice) === false ? [each.machine] : []);
+		if (differs.length) return {
+			kind: "local",
+			placement: `this Mac; auto may use ${differs.join(", ")}, which builds for another architecture, so its key differs`
+		};
+		return {
+			kind: "local",
+			placement: names.length ? `this Mac; auto may use ${names.join(", ")}` : "this Mac"
+		};
+	} catch (error) {
+		return {
+			kind: "unknown",
+			reason: error.message
+		};
+	}
+}
+//#endregion
+export { printPlan as a, planPayload as i, planCachedBuild as n, refusePlan as o, planFlagRefusal as r, runArtifactLifecycle as s, planHostedDevice as t };

package/dist/{ports-4nYqxPWC.mjs → ports-ByPc0_97.mjs}

@@ -1,6 +1,6 @@
-import { p as getProject } from "./config-D0DbpZtM.mjs";
-import { o as findCommandWorkspace } from "./project-D47Rh0ly.mjs";
-import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-C8m8EQs2.mjs";
+import { p as getProject } from "./config-DC5jEtd1.mjs";
+import { n as findCommandWorkspace } from "./project-B5eQ1USs.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-B4iWH4E-.mjs";
 //#region src/commands/ports.ts
 async function inProject(action) {
 	try {

package/dist/{prebuild-D7RUMkwN.mjs → prebuild-BKJ3wJI1.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { r as detectIsExpo } from "./project-D47Rh0ly.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-DqcCbpE7.mjs";
-import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
-import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-CHTyXD0G.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-CR9X86xJ.mjs";
+import { p as detectIsExpo } from "./project-B5eQ1USs.mjs";
+import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
+import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-n3tUi3Em.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 //#region src/engine/prebuild.ts