stim 1.11.0 → 1.13.0

package/dist/{build-plan-CeAYgKAx.mjs → build-plan-BTa93o_r.mjs}

@@ -1,27 +1,25 @@
-import { H as projectDeviceSlots, O as acquireAvdClaim, S as setDevice, T as withConfigLock$1, g as loadConfig$1, i as clearDevice, t as allConsolePortsAndSerials, u as getConfigDir, v as releaseAndroidConsolePort, x as saveConfig, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { B as deviceSlotPlatforms, C as setDevice, E as withConfigLock$1, S as saveConfig, U as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, i as clearAndroidBootPending, k as acquireAvdClaim, t as allConsolePortsAndSerials, y as releaseAndroidConsolePort } from "./config-0jCcMM0E.mjs";
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { S as sharedBuildCache, g as updateWorkspaceState, i as pidExists, k as workspaceId, m as readWorkspaceState$1, s as resolveProjectMetro, x as ensureWorkspaceStorage } from "./metro-BWLOJ_Wr.mjs";
-import { D as makeTemporaryDirectory, O as removeTemporaryEntry, c as gitCommonDirOnDisk } from "./worktree-BlizKDpZ.mjs";
-import { a as detectIsExpo, c as ownedDeviceLabel, s as isPackageResolvable } from "./project-BXZzOABt.mjs";
-import { a as spawnDeclared } from "./spawn-claims-BJwXTMPt.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-Cx74RSDZ.mjs";
+import { A as workspaceId, C as sharedBuildCache, _ as updateWorkspaceState, a as pidExists, h as readWorkspaceState$1 } from "./metro-BPeY1YMh.mjs";
+import { D as makeTemporaryDirectory, O as removeTemporaryEntry, c as gitCommonDirOnDisk } from "./worktree-DeBQSVtR.mjs";
+import { c as ownedDeviceLabel, r as detectIsExpo, s as isPackageResolvable } from "./project-DGeclhvO.mjs";
+import { a as spawnDeclared } from "./spawn-claims-PT8aQpCa.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-n7tnJsI8.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-D5z2_bcF.mjs";
-import { N as storedSources, S as entryDir, x as diffFingerprintSources, y as artifactIn } from "./device-lease-D83nqeMX.mjs";
-import { D as listAvds, F as ownedAvdName, H as resolveOwnedAvdSerial, L as ownedAvdSystemImage, M as ownedAvdDeviceProfile, O as listInstalledSystemImages, P as ownedAvdMatchesConfiguration, S as getAvdNameForSerial, T as listAdbDevices, f as avdPoolConfiguration, g as createOwnedAvd, h as configureNewOwnedAvd, j as nextConsolePort, m as bootAndroidEmulator, q as waitForBoot, t as DEFAULT_AVD_DEVICE_PROFILE, u as assertOwnedAvdStopped, z as pickDefaultSystemImage } from "./android-C4zG2Tuc.mjs";
-import { l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-B5oFZEri.mjs";
-import { _ as dropParked, b as readParked, d as teardownOwnedAvd, g as adoptParked, m as teardownParkedIosSim, p as teardownParkedAvd, v as isLegacyDeletionClaim, x as selectParked, y as parkedMaxSetting } from "./ownership-BiojdtAp.mjs";
-import { E as configuredIosSimulatorViewer, O as hostMemoryPressureAdvice, S as resolveOwnedIosSim, b as resetIosPrivacy, c as iosSimulatorFailureAdvice, d as listIosDeviceTypes, g as parseRuntimeVersion, k as readHostMemoryPressure, l as listAllIosSims, m as ownedSimName, n as bootIosSim, r as createOwnedIosSim, v as renameIosSim, x as resolveIosCreation, y as resetIosKeychain } from "./ios-DArbmwer.mjs";
-import { o as estimateBuild } from "./build-progress-CDwogz6R.mjs";
-import { i as expoBinRefusal, r as expoBinPath, t as cleanLine } from "./server-expo-o6H5gcBc.mjs";
-import { N as easAuthNote } from "./device-remote-BQZSnnmE.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-CuPDGXdr.mjs";
-import { a as liveOwnedDeviceCount, i as deviceTypeMismatch, t as reconcileSimSlim } from "./simslim-CIR3IYJO.mjs";
-import { s as startDevServer } from "./start-BSsf2tUs.mjs";
-import { r as readStats } from "./stats-BAgJaLA4.mjs";
-import { d as startBuildHeartbeat, f as tailLines, n as HEARTBEAT_INTERVAL_MS } from "./xcode-B5SPD--o.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-BIL7rlX7.mjs";
+import { C as diffFingerprintSources, I as storedSources, w as entryDir, y as artifactIn } from "./device-lease-CL9dZf73.mjs";
+import { $ as waitForBoot, A as listInstalledSystemImages, D as listAdbDevices, I as ownedAvdMatchesConfiguration, L as ownedAvdName, N as nextConsolePort, P as ownedAvdDeviceProfile, T as getAvdNameForSerial, U as pickDefaultSystemImage, _ as bootAndroidEmulator, at as dropParked, ct as parkedMaxSetting, d as assertOwnedAvdStopped, dt as selectParked, h as avdPoolConfiguration, it as adoptParked, k as listAvds, lt as readParked, n as OWNED_AVD_CONFIG_DEFAULTS, ot as isLegacyDeletionClaim, q as resolveOwnedAvdSerial, t as DEFAULT_AVD_DEVICE_PROFILE, v as configureNewOwnedAvd, y as createOwnedAvd, z as ownedAvdSystemImage } from "./android-qx_31wJo.mjs";
+import { l as androidDataPartitionSizeGbSetting, o as androidAvdConfigSetting, v as iosSimSlimProfileSetting } from "./settings-xB0Frkg6.mjs";
+import { f as teardownOwnedAvd, g as teardownParkedIosSim, h as teardownParkedAvd } from "./ownership-PUP4Dwai.mjs";
+import { E as configuredIosSimulatorViewer, O as hostMemoryPressureAdvice, S as resolveOwnedIosSim, b as resetIosPrivacy, c as iosSimulatorFailureAdvice, d as listIosDeviceTypes, f as listIosRuntimes, g as parseRuntimeVersion, k as readHostMemoryPressure, l as listAllIosSims, m as ownedSimName, n as bootIosSim, r as createOwnedIosSim, v as renameIosSim, x as resolveIosCreation, y as resetIosKeychain } from "./ios-CmEzZiOj.mjs";
+import { o as estimateBuild } from "./build-progress-l7d-X-ZP.mjs";
+import { i as expoBinRefusal, r as expoBinPath, t as cleanLine } from "./server-expo-DUCg52-K.mjs";
+import { a as easAuthNote } from "./remote-cache--aehr4Pr.mjs";
+import { a as liveOwnedDeviceCount, i as deviceTypeMismatch, o as runtimeMismatch, t as reconcileSimSlim } from "./simslim-Bbg9UWrt.mjs";
+import { r as readStats } from "./stats-D8rUTPHd.mjs";
+import { d as startBuildHeartbeat, f as tailLines, n as HEARTBEAT_INTERVAL_MS } from "./xcode-LM6A8cNZ.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync } from "node:fs";
-import { LAST_BUILD_KEYS, isJsonObject, loadConfig, readIdleStop, readJsonObject, readWorkspaceState } from "@stim-cli/core/state";
+import { LAST_BUILD_KEYS, isJsonObject, loadConfig, readJsonObject, readWorkspaceState } from "@stim-cli/core/state";
 import { basename, dirname, join, relative } from "node:path";
 import { claimRemoveCommand, clearClaimChild, markClaimChildPending, processGroupAlive, releaseClaim, setClaimChild } from "@stim-cli/core/ownership-claim";
 import { captureProcessIdentity } from "@stim-cli/core/process-identity";
@@ -93,73 +91,6 @@ async function warmMetro({ port, platform, isExpo, appId, bundleUrl }) {
 	} catch {}
 }
 //#endregion
-//#region src/commands/native-runtime.ts
-const sleep$1 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function ensureDevServer({ root, port, settings, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
-	const held = port === null ? null : (await resolve(port, root)).metro;
-	if (port !== null && held) return {
-		ok: true,
-		port,
-		pid: held.pid ?? null,
-		devServer: null,
-		reclaimed: []
-	};
-	const reason = readIdleStop(readState(root)) ? "stopped (idle)" : "not running";
-	note(chalk.dim(phaseLine("metro", `dev server ${reason}; starting it${remote ? " for a remote device" : ""}`)));
-	const result = await start({
-		root,
-		settings,
-		remote,
-		out: note,
-		note
-	});
-	if (!result.ok) return {
-		ok: false,
-		code: result.error.code,
-		message: `Could not start this workspace's dev server: ${result.error.message}`,
-		remedy: result.error.remedy,
-		lines: result.lines,
-		reclaimed: result.reclaimed
-	};
-	const { facts } = result;
-	return {
-		ok: true,
-		port: facts.port,
-		pid: facts.supervisorPid,
-		devServer: facts.alreadyRunning ? null : {
-			started: true,
-			reason
-		},
-		reclaimed: result.reclaimed
-	};
-}
-async function ensureWorkspaceStorageSafely(root, { note = (_line) => {} } = {}) {
-	try {
-		return ensureWorkspaceStorage(root);
-	} catch (err) {
-		note(chalk.dim(`Could not prepare this workspace's Stim state: ${err?.message || err}`));
-		throw err;
-	}
-}
-function launchOutcomeRecord({ launchState, release, bundleId, configuration, metroPort }) {
-	const unverified = launchState === LAUNCH_UNVERIFIED;
-	const bundling = launchState === LAUNCH_BUNDLING;
-	let msg;
-	if (release) msg = unverified ? `${bundleId} could not be verified as running after its ${configuration} launch` : `${bundleId} is running its embedded ${configuration} bundle`;
-	else if (unverified) msg = `no bundle request from ${bundleId} reached this workspace's Metro on port ${metroPort}`;
-	else if (bundling) msg = `${bundleId} requested a bundle from this workspace's Metro on port ${metroPort}; it was still being built when the launch check ended`;
-	else msg = `${bundleId} fetched a bundle from this workspace's Metro on port ${metroPort}`;
-	return {
-		src: "build",
-		level: unverified ? "warn" : "info",
-		event: unverified ? "launch_unverified" : bundling ? "launch_bundling" : "launch_verified",
-		msg
-	};
-}
-function isPhysicalDeviceRequest(flag) {
-	return flag !== null && flag !== void 0 && flag !== false;
-}
-//#endregion
 //#region src/engine/device-ios.ts
 function startIosBoot(udid, configure, label, out, simulatorApp) {
 	const done = (async () => {
@@ -183,13 +114,15 @@ async function ensureOwnedIosDevice({ record, projectPath, slot, settingsRoot, l
 	if (record?.deviceUdid) {
 		if (record.owned) {
 			const resolved = resolveOwnedIosSim(record.deviceUdid);
-			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned by name -- creating a fresh owned sim instead of booting it.`));
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded sim is now named "${resolved.notOwned}", not Stim-owned -- creating a fresh owned sim instead of booting it.`));
 			else if (resolved.missing) {} else {
 				const sim = resolved.sim;
 				const wantedType = flags.deviceType || settings?.ios?.deviceType;
 				const deviceTypes = listIosDeviceTypes();
 				const mismatch = deviceTypeMismatch(sim.deviceTypeIdentifier, wantedType, deviceTypes);
 				if (mismatch) throw new Error(`${mismatch}. Stim will not silently boot a different model. Run \`stim worktree remove\` (or \`stim gc --delete\`) to reap the current sim, then \`stim ios\` again to create the requested one.`);
+				const versionMismatch = flags.runtimeFlag ? runtimeMismatch(sim.runtime, flags.runtimeFlag, listIosRuntimes()) : null;
+				if (versionMismatch) throw new Error(`${versionMismatch}. Stim will not silently boot a different iOS version. Run \`stim worktree remove\` (or \`stim gc --delete\`) to reap the current sim, then \`stim ios\` again to create the requested one, or pass \`--slot <name>\` to create it beside the current one.`);
 				const model = {
 					model: deviceTypes.find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null,
 					runtime: parseRuntimeVersion(sim.runtime)
@@ -641,7 +574,10 @@ async function prepareOwnedAvd({ projectPath, slot, label, previousAvdName, syst
 				avdName,
 				owned: true,
 				deviceName: avdName,
-				...prepared.created ? { poolConfiguration: configuration } : {},
+				...prepared.created ? {
+					poolConfiguration: configuration,
+					bootPending: true
+				} : {},
 				...prepared.consolePort ? { consolePort: prepared.consolePort } : {}
 			}, slot);
 		});
@@ -676,10 +612,13 @@ async function prepareOwnedAvd({ projectPath, slot, label, previousAvdName, syst
 const ANDROID_FRESH_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 12e4;
 const ANDROID_BOOT_TIMEOUT_MS = process.platform === "win32" ? 12e5 : 24e4;
 async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoot, label, settings, flags, note, out, logFile, alive, configureAvd, teardownAvd }) {
-	const avdConfig = androidAvdConfigSetting(settings, settingsRoot);
+	const projectAvdConfig = androidAvdConfigSetting(settings, settingsRoot);
+	const avdConfig = {
+		...OWNED_AVD_CONFIG_DEFAULTS,
+		...projectAvdConfig
+	};
 	const requestedProfile = flags.deviceProfile || settings.android?.deviceProfile || null;
-	const deviceProfile = requestedProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
-	const configuration = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), avdConfig, deviceProfile);
+	let replacedProfile = null;
 	if (record?.setupIncomplete && record.avdName) {
 		const avdName = record.avdName;
 		const cleanup = teardownAvd(avdName, {
@@ -696,12 +635,36 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new AvdRecoveryError(`Owned AVD ${record.avdName} has incomplete setup and could not be deleted (${cleanup.reason || cleanup.status}). Fix the cause, then retry; Stim kept the device record for cleanup.`, "Wait for any active AVD operation to finish. If the refusal names an unresolved claim, inspect its creator and native processes before removing only that claim. Retry `stim android` to reconcile the incomplete device.");
 		record = null;
 	}
+	const requestedImage = flags.systemImageFlag || null;
+	const currentImage = requestedImage && record?.owned && record.avdName ? ownedAvdSystemImage(record.avdName) : null;
+	if (record?.avdName && requestedImage && currentImage && currentImage !== requestedImage) {
+		const avdName = record.avdName;
+		if (!record.bootPending) throw new AvdRecoveryError(`this project's emulator ${avdName} uses system image ${currentImage}, but ${requestedImage} was requested. --system-image replaces only an emulator that never finished a boot, and this one has.`, "Run `stim worktree remove` (or `stim gc --delete`) to reap the current emulator, then `stim android` again to create the requested one, or pass `--slot <name>` to create it beside the current one.");
+		replacedProfile = ownedAvdDeviceProfile(avdName);
+		const cleanup = teardownAvd(avdName, {
+			del: true,
+			owner: {
+				projectPath,
+				slot,
+				expectedRecord: record
+			},
+			onRemoved: () => {
+				clearDevice(projectPath, "android", slot, avdName);
+			}
+		});
+		if (cleanup.status === "failed" || cleanup.status === "skipped") throw new AvdRecoveryError(`Owned AVD ${avdName} never finished a boot, but could not be deleted to create one on ${requestedImage} (${cleanup.reason || cleanup.status}). Stim kept the device record.`, "Fix the cause, then retry, or pass `--slot <name>` to create the requested emulator beside it.");
+		out(phaseLine("device", `deleted ${avdName}, which never finished a boot, to create one on ${requestedImage}`));
+		record = null;
+	}
+	const deviceProfile = requestedProfile ?? replacedProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
+	const configuration = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), avdConfig, deviceProfile);
+	const configurationBeforeDefaults = avdPoolConfiguration(androidDataPartitionSizeGbSetting(settings), projectAvdConfig, deviceProfile);
 	if (record?.avdName) {
 		if (record.owned) {
 			const resolved = resolveOwnedAvdSerial(record.avdName);
 			const currentProfile = resolved.notOwned || resolved.missing ? null : ownedAvdDeviceProfile(record.avdName);
 			if (requestedProfile && currentProfile && currentProfile !== requestedProfile) throw new AvdRecoveryError(`this project's emulator uses device profile ${currentProfile}, but ${requestedProfile} was requested. Stim will not silently boot a different model.`, "Run `stim worktree remove` (or `stim gc --delete`) to reap the current emulator, then `stim android` again to create the requested one, or pass `--slot <name>` to create it beside the current one.");
-			if (resolved.notOwned) note(chalk.yellow(`Note: recorded AVD ${record.avdName} is not Stim-owned by name -- creating a fresh owned AVD instead of reusing it.`));
+			if (resolved.notOwned) note(chalk.yellow(`Note: recorded AVD ${record.avdName} is not Stim-owned -- creating a fresh owned AVD instead of reusing it.`));
 			else if (resolved.serial) {
 				const consolePort = Number(resolved.serial.replace(/^emulator-/, ""));
 				if (record.consolePort && record.consolePort !== consolePort) out(phaseLine("device", `${record.avdName} changed serial (emulator-${record.consolePort} -> ${resolved.serial}); reconnecting this run, reopen agent-device on ${resolved.serial}`));
@@ -748,7 +711,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 	}
 	if (parkedMaxSetting("android").max > 0) {
 		const systemImage = pickDefaultSystemImage(listInstalledSystemImages(), { systemImage: flags.systemImage || settings.android?.systemImage })?.pkg;
-		const candidates = readParked("android").filter((entry) => entry.systemImage === systemImage && entry.configuration === configuration).toSorted((a, b) => a.parkedAt.localeCompare(b.parkedAt));
+		const candidates = readParked("android").filter((entry) => entry.systemImage === systemImage && (entry.configuration === configuration || entry.configuration === configurationBeforeDefaults)).toSorted((a, b) => a.parkedAt.localeCompare(b.parkedAt));
 		for (const parked of candidates) {
 			if (isLegacyDeletionClaim(parked.deletionClaim)) continue;
 			const resolved = resolveOwnedAvdSerial(parked.name);
@@ -764,7 +727,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 				out(phaseLine("device", `kept parked ${parked.name}: ${String(error?.message || error)}`));
 				continue;
 			}
-			if (ownedAvdSystemImage(parked.name) !== systemImage || !ownedAvdMatchesConfiguration(parked.name, configuration)) {
+			if (ownedAvdSystemImage(parked.name) !== systemImage || !ownedAvdMatchesConfiguration(parked.name, parked.configuration)) {
 				const result = teardownParkedAvd(parked.name);
 				if (result.status === "failed") out(phaseLine("device", `kept ${parked.name}: ${result.reason}`));
 				continue;
@@ -773,7 +736,7 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 				avdName: parked.name,
 				deviceName: parked.name,
 				owned: true,
-				poolConfiguration: configuration,
+				poolConfiguration: parked.configuration,
 				adoptionPending: true
 			};
 			if (!adoptParked({
@@ -783,6 +746,15 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 				udid: parked.udid,
 				device: adopted
 			})) continue;
+			if (parked.configuration !== configuration) try {
+				configureAvd(parked.name, {
+					dataPartitionSizeGb: androidDataPartitionSizeGbSetting(settings),
+					avdConfig
+				});
+				adopted.poolConfiguration = configuration;
+			} catch (error) {
+				out(phaseLine("device", `${parked.name} keeps its old AVD settings: ${String(error?.message || error)}`));
+			}
 			return {
 				...await bootOwnedAvdOnFreshPort({
 					avdName: parked.name,
@@ -824,7 +796,10 @@ async function ensureOwnedAndroidDevice({ record, projectPath, slot, settingsRoo
 	return {
 		...await bootOwnedAvdOnFreshPort({
 			avdName: created.avdName,
-			metadata: created.created ? { poolConfiguration: configuration } : void 0,
+			metadata: created.created ? {
+				poolConfiguration: configuration,
+				bootPending: true
+			} : void 0,
 			projectPath,
 			slot,
 			deviceName: created.avdName,
@@ -843,6 +818,7 @@ function claimAndroidConsolePort({ projectPath, slot, avdName, deviceName, liveP
 		const claim = {
 			...metadata?.poolConfiguration ? { poolConfiguration: metadata.poolConfiguration } : {},
 			...metadata?.adoptionPending ? { adoptionPending: true } : {},
+			...metadata?.bootPending ? { bootPending: true } : {},
 			avdName,
 			consolePort,
 			owned: true,
@@ -880,8 +856,10 @@ async function bootOwnedAvdOnFreshPort({ avdName, metadata, projectPath, slot, d
 		if (result.failed) throw new AvdBootError(result.reason, result.remedy);
 		const running = getAvdNameForSerial(serial);
 		if (running && running !== avdName) throw new Error(`${serial} is running AVD ${running}, not this workspace's owned AVD ${avdName}; refusing to use it.`);
+		clearAndroidBootPending(projectPath, avdName, slot);
+		const { bootPending: _booted, ...booted } = claim;
 		return {
-			...claim,
+			...booted,
 			serial
 		};
 	} catch (error) {
@@ -958,19 +936,24 @@ async function ensureAndroidBooted({ device, projectPath, slot, timeoutMs, out,
 	};
 	if (resolved.notOwned) return {
 		failed: true,
-		reason: `AVD ${device.avdName} is not Stim-owned by name; refusing to boot it.`
+		reason: `AVD ${device.avdName} is not Stim-owned; refusing to boot it.`
 	};
-	if (resolved.serial) return waitForAndroidBoot({
+	const avdName = device.avdName;
+	const booted = (result) => {
+		if (!result.failed) clearAndroidBootPending(projectPath, avdName, slot);
+		return result;
+	};
+	if (resolved.serial) return booted(await waitForAndroidBoot({
 		serial: resolved.serial,
 		timeoutMs,
 		out
-	});
+	}));
 	const freshSerial = `emulator-${device.consolePort}`;
-	if (device.owned && device.serial === freshSerial) return waitForAndroidBoot({
+	if (device.owned && device.serial === freshSerial) return booted(await waitForAndroidBoot({
 		serial: freshSerial,
 		timeoutMs,
 		out
-	});
+	}));
 	const claim = claimAndroidConsolePort({
 		projectPath,
 		slot,
@@ -1000,7 +983,7 @@ async function ensureAndroidBooted({ device, projectPath, slot, timeoutMs, out,
 		out
 	});
 	if (result.failed) releaseAndroidConsolePort(projectPath, claim.consolePort, slot);
-	return result;
+	return booted(result);
 }
 //#endregion
 //#region src/engine/device.ts
@@ -1776,6 +1759,28 @@ function explainBuildMiss({ root, platform, current, rekeyedBy = [], baselineDep
 		previousHash: baseline?.fingerprint ?? null
 	};
 }
+function predictBuildMiss({ root, platform, current, prebuild }) {
+	const { reason } = explainBuildMiss({
+		root,
+		platform,
+		current
+	});
+	const baseline = reason.baseline && {
+		fingerprint: reason.baseline.fingerprint,
+		from: reason.baseline.from
+	};
+	if (!prebuild || !baseline) return {
+		...reason,
+		baseline
+	};
+	const dir = platform === "ios" ? "ios/" : "android/";
+	return {
+		...reason,
+		kind: "prebuild-pending",
+		summary: `${reason.summary} (before prebuild ${prebuild}s ${dir})`,
+		baseline
+	};
+}
 function skippedMissReason(summary) {
 	return {
 		kind: "cache-skipped",
@@ -1887,6 +1892,7 @@ async function planCachedBuild(lookup, deps) {
 	}
 	let prebuild = null;
 	let refusal = null;
+	let missReason;
 	if (!cacheHit) {
 		prebuild = deps.planPrebuild(root, platform, {
 			isExpo,
@@ -1894,6 +1900,15 @@ async function planCachedBuild(lookup, deps) {
 			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,
@@ -1902,11 +1917,12 @@ async function planCachedBuild(lookup, deps) {
 		provider,
 		cacheSkipped: !cachePolicy.read,
 		prebuild,
+		...missReason ? { missReason } : {},
 		refusal
 	});
 }
 function planPayload({ platform, slot, projectKey }, found) {
-	const { refusal, ...rest } = found;
+	const { refusal, missReason, ...rest } = found;
 	const outcome = refusal ? null : found.cacheHit ? "hit" : "cold";
 	const estimate = outcome ? estimateBuild(readStats().record?.history?.[projectKey], platform, outcome, "prepare") : {
 		expectedMs: null,
@@ -1919,6 +1935,7 @@ function planPayload({ platform, slot, projectKey }, found) {
 		outcome,
 		expectedMs: estimate.expectedMs,
 		basis: estimate.basis,
+		...missReason ? { missReason } : {},
 		...refusal ? { refusal } : {}
 	};
 }
@@ -1935,6 +1952,7 @@ function printPlan(plan, json) {
 	}
 	const slot = plan.slot ? ` [${plan.slot}]` : "";
 	console.log(phaseLine("plan", `${plan.platform}${slot} ${shortHash(plan.fingerprint)} -> ${cacheLine(plan)}`));
+	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));
@@ -1963,4 +1981,4 @@ function planFlagRefusal(flag) {
 	};
 }
 //#endregion
-export { ensureDevServer as C, sleep$1 as D, launchOutcomeRecord as E, warmMetro as O, clearIosAdoptionPending as S, isPhysicalDeviceRequest as T, staleNativeDirRefusal as _, refusePlan as a, AvdBootError as b, skippedMissReason as c, schemesFromInfoPlist as d, detectEntryFile as f, runPrebuild as g, recordPrebuild as h, printPlan as i, devClientScheme as l, planPrebuild as m, planFlagRefusal as n, explainBuildMiss as o, swapJsBundle as p, planPayload as r, fingerprintErrorMissReason as s, planCachedBuild as t, pickDevClientScheme as u, ensureBooted as v, ensureWorkspaceStorageSafely as w, AvdRecoveryError as x, ensureOwnedDevice as y };
+export { warmMetro as C, clearIosAdoptionPending as S, staleNativeDirRefusal as _, refusePlan as a, AvdBootError as b, skippedMissReason as c, schemesFromInfoPlist as d, detectEntryFile as f, runPrebuild as g, recordPrebuild as h, printPlan as i, devClientScheme as l, planPrebuild as m, planFlagRefusal as n, explainBuildMiss as o, swapJsBundle as p, planPayload as r, fingerprintErrorMissReason as s, planCachedBuild as t, pickDevClientScheme as u, ensureBooted as v, AvdRecoveryError as x, ensureOwnedDevice as y };

package/dist/{build-progress-CDwogz6R.mjs → build-progress-l7d-X-ZP.mjs}

@@ -1,7 +1,7 @@
-import { k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
-import { f as clearWorkspaceStateKey, g as updateWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
-import { a as formatElapsed, u as plural } from "./command-output-D5z2_bcF.mjs";
-import { BUILD_PHASES } from "@stim-cli/core/state";
+import { A as ownership_claim_exports } from "./config-0jCcMM0E.mjs";
+import { _ as updateWorkspaceState, p as clearWorkspaceStateKey } from "./metro-BPeY1YMh.mjs";
+import { a as formatElapsed, u as plural } from "./command-output-BIL7rlX7.mjs";
+import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, LAST_BUILD_KEYS } from "@stim-cli/core/state";
 //#region src/engine/build-progress.ts
 const ACTIVE_BUILD_KEY = "activeBuild";
 const NO_BUILD_PROGRESS = {
@@ -44,11 +44,11 @@ function startBuildProgress({ root, platform, slot, claim, now = Date.now, note
 			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
 		}
 	};
-	const write = () => guard(() => updateWorkspaceState(root, (state) => ({
-		...state,
+	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
+		...before(state),
 		[ACTIVE_BUILD_KEY]: record
 	})));
-	write();
+	write(withInterruptedBuild);
 	return {
 		step(phase) {
 			if (phase === record.phase) return;
@@ -82,6 +82,74 @@ function phaseDurations(phases, now) {
 	});
 	return out;
 }
+const HISTORY_FIELDS = [
+	"platform",
+	"status",
+	"configuration",
+	"fingerprint",
+	"cacheKey",
+	"cacheHit",
+	"cacheSkipped",
+	"durationMs",
+	"startedAt",
+	"errorCode",
+	"missReason",
+	"diagnostics"
+];
+function withHistoryEntry(state, platform, entry) {
+	const saved = state[BUILD_HISTORY_KEY];
+	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
+	const list = Array.isArray(history[platform]) ? history[platform] : [];
+	return {
+		...state,
+		[BUILD_HISTORY_KEY]: {
+			...history,
+			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
+		}
+	};
+}
+function finishedResult(record) {
+	if (record.status === "ok") return "succeeded";
+	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
+}
+function recordFinishedBuild(root, record, { update = updateWorkspaceState, now = Date.now } = {}) {
+	const platform = record.platform;
+	update(root, (state) => {
+		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+		const own = active?.platform === platform ? active : null;
+		const entry = {
+			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
+			result: finishedResult(record),
+			slot: own?.slot ?? "default",
+			phases: own ? phaseDurations(own.phases, now()) : {}
+		};
+		return withHistoryEntry({
+			...state,
+			lastBuild: record,
+			[LAST_BUILD_KEYS[platform]]: record
+		}, platform, entry);
+	});
+}
+function withInterruptedBuild(state) {
+	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+	if (!left) return state;
+	const last = state[LAST_BUILD_KEYS[left.platform]];
+	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
+	return withHistoryEntry(state, left.platform, {
+		platform: left.platform,
+		status: "failed",
+		result: "interrupted",
+		slot: left.slot,
+		configuration: null,
+		fingerprint: null,
+		cacheKey: null,
+		cacheHit: false,
+		cacheSkipped: false,
+		durationMs: null,
+		startedAt: left.startedAt,
+		phases: phaseDurations(left.phases, Date.parse(left.phaseStartedAt))
+	});
+}
 function parseActiveBuild(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 	const record = value;
@@ -176,4 +244,4 @@ function buildStatusLine(report, now) {
 	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
 }
 //#endregion
-export { buildStatusLine as a, startBuildProgress as c, buildReport as i, NO_BUILD_PROGRESS as n, estimateBuild as o, activeBuildState as r, parseActiveBuild as s, ACTIVE_BUILD_KEY as t };
+export { buildStatusLine as a, recordFinishedBuild as c, buildReport as i, startBuildProgress as l, NO_BUILD_PROGRESS as n, estimateBuild as o, activeBuildState as r, parseActiveBuild as s, ACTIVE_BUILD_KEY as t };

package/dist/{cache-manifest-Pubfp8wV.mjs → cache-manifest-DWPF4RKJ.mjs}

@@ -1,4 +1,4 @@
-import { u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { d as getConfigDir } from "./config-0jCcMM0E.mjs";
 import { existsSync } from "fs";
 import { isAbsolute, join, resolve } from "path";
 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-Pubfp8wV.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-DWPF4RKJ.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cdp-Dq_ypAlJ.mjs

@@ -0,0 +1,115 @@
+import { WebSocket } from "ws";
+//#region src/web/cdp.ts
+const COMMAND_TIMEOUT_MS = 15e3;
+function connectCdp(url, { timeoutMs = 5e3 } = {}) {
+	return new Promise((resolve, reject) => {
+		const socket = new WebSocket(url, {
+			perMessageDeflate: false,
+			maxPayload: 268435456
+		});
+		const pending = /* @__PURE__ */ new Map();
+		const eventListeners = [];
+		const closeListeners = [];
+		let nextId = 1;
+		let closed = false;
+		const timer = setTimeout(() => {
+			socket.terminate();
+			reject(/* @__PURE__ */ new Error(`DevTools did not accept a connection at ${url} within ${timeoutMs}ms`));
+		}, timeoutMs);
+		socket.on("message", (data) => {
+			let message;
+			try {
+				message = JSON.parse(String(data));
+			} catch {
+				return;
+			}
+			if (typeof message.id === "number") {
+				const waiter = pending.get(message.id);
+				if (!waiter) return;
+				pending.delete(message.id);
+				if (message.error) waiter.reject(new Error(message.error.message ?? "DevTools command failed"));
+				else waiter.resolve(message.result ?? {});
+				return;
+			}
+			if (typeof message.method === "string") {
+				const event = {
+					method: message.method,
+					params: message.params ?? {},
+					...message.sessionId ? { sessionId: message.sessionId } : {}
+				};
+				for (const listener of eventListeners) listener(event);
+			}
+		});
+		socket.on("close", () => {
+			closed = true;
+			for (const waiter of pending.values()) waiter.reject(/* @__PURE__ */ new Error("DevTools connection closed"));
+			pending.clear();
+			for (const listener of closeListeners) listener();
+		});
+		socket.on("error", (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+		socket.on("open", () => {
+			clearTimeout(timer);
+			resolve({
+				send(method, params = {}, sessionId) {
+					if (closed) return Promise.reject(/* @__PURE__ */ new Error("DevTools connection closed"));
+					const id = nextId++;
+					return new Promise((resolveCommand, rejectCommand) => {
+						const commandTimer = setTimeout(() => {
+							pending.delete(id);
+							rejectCommand(/* @__PURE__ */ new Error(`DevTools command ${method} timed out`));
+						}, COMMAND_TIMEOUT_MS);
+						pending.set(id, {
+							resolve: (value) => {
+								clearTimeout(commandTimer);
+								resolveCommand(value);
+							},
+							reject: (error) => {
+								clearTimeout(commandTimer);
+								rejectCommand(error);
+							}
+						});
+						socket.send(JSON.stringify({
+							id,
+							method,
+							params,
+							...sessionId ? { sessionId } : {}
+						}));
+					});
+				},
+				onEvent(listener) {
+					eventListeners.push(listener);
+				},
+				onClose(listener) {
+					if (closed) listener();
+					else closeListeners.push(listener);
+				},
+				close() {
+					socket.close();
+				}
+			});
+		});
+	});
+}
+/**
+* Connects to the browser DevTools endpoint on loopback `port` only when the process serving it is `chromePid`,
+* the Chrome Stim started. Chrome reports its own browser process through `SystemInfo.getProcessInfo`.
+*/
+async function connectOwnedBrowser(port, chromePid) {
+	const { webSocketDebuggerUrl } = await (await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(2e3) })).json();
+	if (typeof webSocketDebuggerUrl !== "string" || !webSocketDebuggerUrl.startsWith(`ws://127.0.0.1:${port}/`)) throw new Error(`port ${port} does not serve a browser DevTools endpoint`);
+	const cdp = await connectCdp(webSocketDebuggerUrl);
+	try {
+		const { processInfo } = await cdp.send("SystemInfo.getProcessInfo");
+		const browser = processInfo?.find((entry) => entry.type === "browser")?.id;
+		if (browser !== chromePid) throw new Error(`port ${port} is served by browser pid ${browser ?? "unknown"}, not the owned Chrome ${chromePid}`);
+		return cdp;
+	} catch (error) {
+		cdp.close();
+		throw error;
+	}
+}
+//#endregion
+export { connectOwnedBrowser as t };