stim 1.18.0 → 1.20.0

package/dist/plan-BDk2AeY_.mjs

@@ -0,0 +1,260 @@
+import { p as getProject, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { B as remoteAndroidSetting, F as parseIosRemote, Q as settingShapeErrors, U as resolveAndroidLayout, W as resolveCacheProviderConfig, Y as settingFile, Z as settingOriginScope, a as SETTING_SHAPE_REMEDY, d as androidLayoutSetting, et as settingsLayers, f as androidLayoutSettingError, nt as unknownSettingKeys, p as cacheProviderSettingError, s as androidAvdConfigSettingError, u as androidDataPartitionSizeGbSettingError } from "./settings-Bbztm4oV.mjs";
+import { _ as detectIsExpo } from "./project-B8_duAzW.mjs";
+import { B as ownedAvdSystemImage, F as ownedAvdDeviceProfile, K as profileNeedsFoldFeature, Q as systemImageSupportsFold, W as pickDefaultSystemImage, dt as parkedMaxSetting, j as listInstalledSystemImages, k as listAvdDeviceProfiles, t as DEFAULT_AVD_DEVICE_PROFILE } from "./android-BsYNR81W.mjs";
+import { d as optimizationBuildProfile, l as artifactCachePolicy, p as resolveOptimizations, u as compilerCacheFallbackMessage } from "./errors-DzkMYh8Q.mjs";
+import { r as isPhysicalDeviceRequest } from "./native-runtime-BRmWL7ru.mjs";
+import { t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-Ca_ke1LE.mjs";
+import { C as remoteAvdFlagRefusal, D as systemImageRefusal, E as resolveVariant, T as resolveSystemImage, m as deviceProfileRefusal, v as foldableImageRefusal, w as resolveDeviceProfile, y as isReleaseVariant } from "./support-CnE_SIjt.mjs";
+import { c as readProductFlavors, s as productFlavorRefusal } from "./react-native-build-oAw6gQeW.mjs";
+import { n as resolveAndroidCas, r as resolveAndroidCompilerCache } from "./android-cas-DCAuXryb.mjs";
+import { l as parseDeviceWait } from "./device-lease-run-CvDeHTkG.mjs";
+//#region src/integrations/android-project.ts
+var AndroidRecipeRefusal = class extends Error {
+	failure;
+	missReason;
+	constructor(failure, missReason) {
+		super(failure.message ?? failure.code);
+		this.failure = failure;
+		this.missReason = missReason;
+	}
+};
+//#endregion
+//#region src/commands/android/plan.ts
+function slotOwnedAvd(projectPath, slot) {
+	const android = deviceSlotPlatforms(getProject(projectPath), slot)?.android;
+	if (!android?.owned || !android.avdName || android.setupIncomplete) return null;
+	const systemImage = ownedAvdSystemImage(android.avdName);
+	return systemImage ? {
+		avdName: android.avdName,
+		systemImage,
+		deviceProfile: ownedAvdDeviceProfile(android.avdName)
+	} : null;
+}
+function fail(code, message, remedy, { lines = [] } = {}) {
+	return {
+		ok: false,
+		code,
+		message,
+		remedy,
+		lines
+	};
+}
+function androidLayoutError(settings, root, bound, isExpo) {
+	const error = androidLayoutSettingError(settings, root, bound);
+	if (error || !androidLayoutSetting(settings, root, bound).custom || !isExpo()) return error;
+	return "android.gradleRoot and android.module apply to bare React Native apps only: expo prebuild generates and builds android/. Remove them for this Expo app.";
+}
+function androidCompilerCache({ root, optimizations, settingsContext, layout }) {
+	const { cas, optimizations: resolved } = resolveAndroidCompilerCache({
+		optimizations,
+		use: (manifest) => resolveAndroidCas(root, {
+			...process.env,
+			STIM_ANDROID_CAS_TOOLCHAIN: manifest
+		}, layout)
+	});
+	const fallback = resolved.android.compilerCacheFallback;
+	if (!fallback) return {
+		cas,
+		optimizations: resolved,
+		warning: null
+	};
+	return {
+		cas,
+		optimizations: resolved,
+		warning: `Warning: ${compilerCacheFallbackMessage({
+			fallback,
+			compilerCache: resolved.android.compilerCache === "none" ? "none" : "ccache",
+			file: settingFile(settingsContext, fallback.key)
+		})}`
+	};
+}
+function resolveAndroidBuildPlan({ settings, settingsContext, easProfile, variant: variantFlag, buildCache: requestedBuildCache }, { warn, runtimeKind, resolveCompilerCache = androidCompilerCache, resolveCacheProvider = resolveCacheProviderConfig, variantProblem, detectExpo = () => detectIsExpo(settingsContext.projectPath) }) {
+	const root = settingsContext.projectPath;
+	const [shapeError, ...moreShapeErrors] = settingShapeErrors(settings);
+	if (shapeError) return fail("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY, { lines: moreShapeErrors });
+	const bound = settingsContext.repoRoot ?? root;
+	const layoutError = androidLayoutError(settings, root, bound, detectExpo);
+	if (layoutError) return fail("STIM_BAD_ARG", layoutError, SETTING_SHAPE_REMEDY);
+	const layout = resolveAndroidLayout(settings, root, bound);
+	for (const key of unknownSettingKeys(settings)) warn("setting", `Warning: setting "${key}" is not read by Stim and will be ignored.`);
+	let optimizations;
+	try {
+		optimizations = resolveOptimizations(settings);
+	} catch (error) {
+		return fail("STIM_BAD_ARG", `Could not configure Android build: ${error.message}`, SETTING_SHAPE_REMEDY);
+	}
+	const compilerCache = resolveCompilerCache({
+		root,
+		optimizations,
+		settingsContext,
+		layout
+	});
+	const cas = compilerCache.cas;
+	optimizations = compilerCache.optimizations;
+	if (compilerCache.warning) warn("cache", compilerCache.warning);
+	const buildProfile = optimizationBuildProfile("android", optimizations);
+	const cacheProviderConfig = resolveCacheProvider(settingsContext);
+	const cacheProviderError = cacheProviderSettingError(settings);
+	if (cacheProviderError) warn("cache", `${cacheProviderError} Using the local cache.`);
+	const variant = easProfile !== void 0 ? "debug" : resolveVariant(variantFlag, settings);
+	const flavorRefusal = variantProblem(variant);
+	if (flavorRefusal) return fail(flavorRefusal.code, flavorRefusal.reason, flavorRefusal.remedy);
+	const release = isReleaseVariant(variant);
+	return {
+		ok: true,
+		plan: {
+			build: {
+				variant,
+				release,
+				profile: buildProfile,
+				cas,
+				cache: artifactCachePolicy(optimizations, requestedBuildCache, runtimeKind({ release }) === "embedded-js"),
+				compilerCache: optimizations.android.compilerCache,
+				gradleBuildCache: optimizations.android.gradleBuildCache,
+				pch: optimizations.android.pch,
+				targetAbiOnly: optimizations.android.targetAbiOnly
+			},
+			metroWarmup: optimizations.metroWarmup,
+			cacheProviderConfig
+		}
+	};
+}
+function resolveAndroidRunPlan({ settings, settingsContext, slot, easProfile, variant: variantFlag, systemImage: systemImageFlag, deviceProfile: deviceProfileFlag, device: deviceFlag, wait: waitFlag, waitConflict, remote: commandRemoteBackend, buildCache: requestedBuildCache }, { warn, runtimeKind, resolveCompilerCache = androidCompilerCache, resolveCacheProvider = resolveCacheProviderConfig, validateAvdConfig = androidAvdConfigSettingError, readFlavors = readProductFlavors, variantProblem = (variant) => productFlavorRefusal({
+	flavors: readFlavors(resolveAndroidLayout(settings, settingsContext.projectPath, settingsContext.repoRoot ?? settingsContext.projectPath)),
+	variant
+}), detectExpo = () => detectIsExpo(settingsContext.projectPath), listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfiles, parkedLimit = parkedMaxSetting, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd }) {
+	const root = settingsContext.projectPath;
+	const [shapeError, ...moreShapeErrors] = [parkedLimit("android").error, ...settingShapeErrors(settings)].filter((error) => Boolean(error));
+	if (shapeError) return fail("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY, { lines: moreShapeErrors });
+	const plannedBuild = resolveAndroidBuildPlan({
+		settings,
+		settingsContext,
+		easProfile,
+		variant: variantFlag,
+		buildCache: requestedBuildCache
+	}, {
+		warn,
+		runtimeKind,
+		resolveCompilerCache,
+		resolveCacheProvider,
+		variantProblem,
+		detectExpo
+	});
+	if (!plannedBuild.ok) return plannedBuild;
+	const dataPartitionSizeError = androidDataPartitionSizeGbSettingError(settings);
+	if (dataPartitionSizeError) return fail("STIM_BAD_ARG", dataPartitionSizeError, "Set android.dataPartitionSizeGb to a whole number of GiB from 6 through 16384.");
+	const avdConfigError = validateAvdConfig(settings, root);
+	if (avdConfigError) return fail("STIM_BAD_ARG", avdConfigError, "Use only documented android.avdConfig keys, or an android.avdConfigFile fragment contained by the app directory.");
+	const systemImage = resolveSystemImage(systemImageFlag, settings);
+	const deviceProfile = resolveDeviceProfile(deviceProfileFlag, settings);
+	const isExpo = detectExpo();
+	const physical = isPhysicalDeviceRequest(deviceFlag);
+	if (physical && deviceFlag === "") return fail("STIM_BAD_ARG", "--device was given an empty serial.", "Pass `--device` on its own to take the first connected device this workspace can lease, or `--device <serial>` to name one.");
+	if (physical && commandRemoteBackend) return fail("STIM_BAD_ARG", "--device installs on a device connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote.");
+	const noWait = waitFlag === false;
+	if (waitConflict) return fail("STIM_BAD_ARG", "--wait and --no-wait ask for opposite things.", "Pass only one of `--wait <seconds>` and `--no-wait`.");
+	const waitParsed = parseDeviceWait(noWait ? void 0 : waitFlag);
+	if ("error" in waitParsed) return fail("STIM_BAD_ARG", waitParsed.error, "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a busy lease or device slot at once.");
+	const waitSeconds = waitParsed.seconds;
+	const remoteTarget = commandRemoteBackend !== null ? parseIosRemote(commandRemoteBackend) : remoteAndroidSetting(settings);
+	if (physical && remoteTarget?.kind === "machine") return fail("STIM_BAD_ARG", "--device installs on a phone connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote; unset android.remote for a local phone.");
+	const machine = remoteTarget?.kind === "machine" ? remoteTarget.machine : null;
+	const remoteBackend = !physical && remoteTarget?.kind === "backend" ? remoteTarget.backend : null;
+	if (!machine) {
+		const refusal = androidDeviceSelectorRefusal({
+			settingsContext,
+			slot,
+			systemImageFlag,
+			deviceProfileFlag,
+			systemImage,
+			deviceProfile,
+			physical,
+			remoteBackend
+		}, {
+			listSystemImages,
+			listDeviceProfiles,
+			supportsFold,
+			ownedAvd
+		});
+		if (refusal) return refusal;
+	}
+	const target = physical ? {
+		kind: "physical",
+		serial: typeof deviceFlag === "string" ? deviceFlag : null,
+		lease: {
+			waitSeconds,
+			noWait
+		}
+	} : machine ? {
+		kind: "hosted",
+		machine,
+		systemImage,
+		deviceProfile
+	} : remoteBackend ? {
+		kind: "remote",
+		backend: remoteBackend,
+		systemImage,
+		deviceProfile
+	} : {
+		kind: "emulator",
+		systemImage,
+		deviceProfile
+	};
+	return {
+		ok: true,
+		plan: {
+			...plannedBuild.plan,
+			target,
+			deviceSlotWaitMs: noWait ? 0 : waitFlag === void 0 && !physical ? DEFAULT_DEVICE_SLOT_WAIT_MS : waitSeconds * 1e3,
+			isExpo
+		}
+	};
+}
+function androidDeviceSelectorRefusal({ settingsContext, slot, systemImageFlag, deviceProfileFlag, systemImage, deviceProfile, physical, remoteBackend }, { listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfiles, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd } = {}) {
+	const root = settingsContext.projectPath;
+	const settingsLayersForOrigin = settingsLayers(settingsContext);
+	const imageRefusal = systemImageRefusal({
+		slot,
+		flag: systemImageFlag,
+		resolved: systemImage,
+		origin: settingOriginScope(settingsLayersForOrigin, "android.systemImage"),
+		physical,
+		remoteBackend,
+		listImages: listSystemImages
+	});
+	if (imageRefusal) return fail(imageRefusal.code, imageRefusal.message, imageRefusal.remedy);
+	const profileRefusal = deviceProfileRefusal({
+		flag: deviceProfileFlag,
+		resolved: deviceProfile,
+		origin: settingOriginScope(settingsLayersForOrigin, "android.deviceProfile"),
+		physical,
+		remoteBackend,
+		listProfiles: listDeviceProfiles
+	});
+	if (profileRefusal) return fail(profileRefusal.code, profileRefusal.message, profileRefusal.remedy);
+	const avdFlagRefusal = remoteAvdFlagRefusal({
+		systemImageFlag,
+		deviceProfileFlag,
+		remoteBackend
+	});
+	if (avdFlagRefusal) return fail(avdFlagRefusal.code, avdFlagRefusal.message, avdFlagRefusal.remedy);
+	if (!physical && !remoteBackend) {
+		const flagImage = typeof systemImageFlag === "string" && systemImageFlag.trim() ? systemImageFlag.trim() : null;
+		const existing = ownedAvd(root, slot);
+		const profile = deviceProfile ?? existing?.deviceProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
+		const image = () => flagImage ?? existing?.systemImage ?? systemImage ?? pickDefaultSystemImage(listSystemImages())?.pkg ?? null;
+		const checked = profileNeedsFoldFeature(profile) ? image() : null;
+		const foldRefusal = checked !== null && foldableImageRefusal({
+			profile,
+			image: checked,
+			avdName: existing && existing.systemImage === checked && existing.deviceProfile === profile ? existing.avdName : null,
+			images: listSystemImages,
+			supportsFold
+		});
+		if (foldRefusal) return fail(foldRefusal.code, foldRefusal.message, foldRefusal.remedy);
+	}
+	return null;
+}
+//#endregion
+export { AndroidRecipeRefusal as i, resolveAndroidBuildPlan as n, resolveAndroidRunPlan as r, androidDeviceSelectorRefusal as t };

package/dist/plan-placement-D_YYlE6N.mjs

@@ -0,0 +1,73 @@
+import { S as hostingMachines } from "./client-BLy1Pw2V.mjs";
+import { r as readHostedNative } from "./ios-state-CjrL2qv-.mjs";
+import { l as probeHost, s as automaticDevicePlacement } from "./build-plan-CP0tckNU.mjs";
+import { automaticMachineEnabled } from "@stim-cli/core/state";
+//#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 { planHostedDevice as t };

package/dist/{ports-BLTtfBq-.mjs → ports-jzvAJXXL.mjs}

@@ -1,6 +1,6 @@
-import { p as getProject } from "./config-CgYMahz7.mjs";
-import { o as findCommandWorkspace } from "./project-C3ChRLZy.mjs";
-import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-BFIz1Shz.mjs";
+import { p as getProject } from "./config-D0LhTY3S.mjs";
+import { n as findCommandWorkspace } from "./project-B8_duAzW.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-C2lvoPsb.mjs";
 //#region src/commands/ports.ts
 async function inProject(action) {
 	try {

package/dist/{prebuild-juCyreaR.mjs → prebuild-Bw44QxVh.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-CSIFuuDa.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { i as detectIsExpo } from "./project-C3ChRLZy.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-C59dqG-Z.mjs";
+import { _ as detectIsExpo } from "./project-B8_duAzW.mjs";
 import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
-import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-DoBHhuzK.mjs";
+import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-CsYu2aKL.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 //#region src/engine/prebuild.ts

package/dist/{preview-D5V07Nrl.mjs → preview-BaBJ72Al.mjs}

@@ -1,29 +1,28 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { o as formatLongDuration, u as plural } from "./command-output-CBtzyIgF.mjs";
-import { H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, p as getProject } from "./config-CgYMahz7.mjs";
-import { C as sourceCheckoutOf, b as resolveFullRef, d as hasUncommittedWork, l as hasPopulatedSubmodules, m as listWorktrees, o as dirtyPaths, w as unpushedCommits } from "./worktree-CsKYexJM.mjs";
-import { s as findProjectRoot$1 } from "./project-C3ChRLZy.mjs";
-import { C as workspaceStateFile, r as readWorkspaceState$1, s as workspaceLastUsed, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
-import { n as readManifest } from "./cache-manifest-BI7ozfmH.mjs";
-import { At as phase, G as DEVICE_LIST_TIMEOUT_MS, Zt as discoverCaches, c as readVolumeSpace, i as enforceBudget, l as resolveBudget, o as machineNumber, pt as planCacheEmptying, r as cacheLabel, u as trimmableCaches } from "./budget-DIhL2BKx.mjs";
-import { I as canonicalPath, M as listBuildSlots, P as recordGcResult, a as collectWorkspaceOutputs, c as listWorkspaceDirs, i as collectOrphanedWorkspaces, p as workspaceInUse, s as isInsideWorkspaces } from "./workspaces-xXItD8Dj.mjs";
-import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-Co-EwifR.mjs";
-import { pt as readParked, z as ownedAvdSerialResolver } from "./android-DC3ZLuw0.mjs";
-import { M as readHostMemoryPressure, d as listAllIosSims } from "./ios-B3SbOWdw.mjs";
-import { D as projectMaintenancePinned } from "./settings-CQyMElEP.mjs";
-import { a as metroStoreRoot } from "./metro-store-BAHFcJm6.mjs";
-import { n as describePullRequest, o as pullRequestLookups, r as endedPullRequest } from "./pull-request-u4vp7zmK.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, p as getProject } from "./config-D0LhTY3S.mjs";
+import { n as readManifest } from "./cache-manifest-qA3dT2x2.mjs";
+import { At as sourceCheckoutOf, Dt as resolveFullRef, E as maintenanceKeepSetting, K as resolveProjectSettings, gt as hasPopulatedSubmodules, jt as unpushedCommits, pt as dirtyPaths, vt as hasUncommittedWork, xt as listWorktrees } from "./settings-Bbztm4oV.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-DHOBXGgS.mjs";
+import { E as workspaceStateFile, r as readWorkspaceState$1, s as workspaceLastUsed, w as workspaceLogsDir$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-BjPN99ZB.mjs";
+import { r as findProjectRoot } from "./project-B8_duAzW.mjs";
+import { ft as readParked, z as ownedAvdSerialResolver } from "./android-BsYNR81W.mjs";
+import { C as recordGcResult, I as listBuildSlots, T as canonicalPath, a as collectWorkspaceOutputs, c as listWorkspaceDirs, i as collectOrphanedWorkspaces, p as workspaceInUse, s as isInsideWorkspaces } from "./workspaces-D2xSHBDY.mjs";
+import { _ as DEVICE_LIST_TIMEOUT_MS, at as discoverCaches, c as readVolumeSpace, i as enforceBudget, l as resolveBudget, nt as phase, o as machineNumber, r as cacheLabel, u as trimmableCaches, z as planCacheEmptying } from "./budget-BONq9vXY.mjs";
+import { s as metroStoreRoot } from "./errors-DzkMYh8Q.mjs";
+import { P as readHostMemoryPressure, d as listAllIosSims } from "./ios-CXLIUxXJ.mjs";
+import { n as describePullRequest, o as pullRequestLookups, r as endedPullRequest } from "./pull-request-vOhLNmIb.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
-import { o as fetchDefaultBranch, s as mergeState } from "./warm-progress-CjB-MP6H.mjs";
-import { f as removeWorktreeTarget, i as matchWorktreeEntry, n as excludePodChurn, o as reclaimKeys, r as excludeWatchmanCookies } from "./worktree-BSYlofkq.mjs";
+import { o as fetchDefaultBranch, s as mergeState } from "./warm-progress-C3ASD6z5.mjs";
+import { a as matchWorktreeEntry, i as excludeWatchmanCookies, p as removeWorktreeTarget, r as excludePodChurn, s as reclaimKeys } from "./worktree-BxDqaTev.mjs";
 import { existsSync } from "node:fs";
 import { basename, isAbsolute, join, sep } from "node:path";
 import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
-import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, buildWorkerRoot, loadConfig, readMaintenanceState, settingDefinition, sharedCcache, sharedCompilationCache } from "@stim-cli/core/state";
-import { cpus, freemem, loadavg, totalmem } from "node:os";
-import chalk from "chalk";
+import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, buildWorkerRoot, loadConfig, readBuildHistory, readMaintenanceState, settingDefinition, sharedCcache, sharedCompilationCache } from "@stim-cli/core/state";
 import { existsSync as existsSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
 import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
+import { cpus, freemem, loadavg, totalmem } from "node:os";
+import chalk from "chalk";
 //#region src/maintenance/measure.ts
 function measureDisk() {
 	return readVolumeSpace([
@@ -586,6 +585,10 @@ function protectedCacheKeys(config = loadConfig$1()) {
 	for (const root of Object.keys(config?.projects ?? {})) {
 		const state = readWorkspaceState$1(root);
 		for (const name of BUILD_RECORDS) for (const key of recordKeys(state?.[name])) keys.add(key);
+		for (const entries of Object.values(readBuildHistory(state))) {
+			const key = entries.find((entry) => entry.result === "succeeded")?.cacheKey;
+			if (key) keys.add(key);
+		}
 	}
 	for (const platform of ["ios", "android"]) for (const record of readParked(platform, { config })) if (record.cacheKey) keys.add(record.cacheKey);
 	for (const lock of listBuildLocks()) if ((lock.alive || lock.unresolved) && lock.key) keys.add(lock.key);
@@ -613,6 +616,13 @@ function cacheEntryProtection(config = loadConfig$1()) {
 		return () => reason;
 	}
 }
+function maintenancePinned(root) {
+	try {
+		return maintenanceKeepSetting(resolveProjectSettings(root).settings);
+	} catch {
+		return true;
+	}
+}
 function recentUse(workspace, settings) {
 	const since = Date.now() - workspaceLastUsed(workspace);
 	return Number.isFinite(since) && since < settings.protectRecentHours * 36e5 ? `used within the last ${settings.protectRecentHours} hours` : null;
@@ -865,7 +875,7 @@ async function planWorktrees({ protectedRoot, pinned, now }) {
 //#endregion
 //#region src/maintenance/preview.ts
 function triggeringRoot() {
-	return canonicalPath(findProjectRoot$1(process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
+	return canonicalPath(findProjectRoot(process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
 }
 async function plannedMaintenance(pressure, sizes, settings, { devices = true, sweep = false, worktrees = false } = {}) {
 	const resolved = resolveBudget();
@@ -890,24 +900,31 @@ async function plannedMaintenance(pressure, sizes, settings, { devices = true, s
 		now: Date.now(),
 		measure: false
 	});
+	const currentSizes = sizes.map((size) => {
+		if (size.category === "compilation-cache") return {
+			...size,
+			blocked: cacheBlocked(size)
+		};
+		if (!size.workspace) return size;
+		const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
+		return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
+	});
+	const pins = /* @__PURE__ */ new Map();
+	const pinned = (workspace) => {
+		let value = pins.get(workspace);
+		if (value === void 0) pins.set(workspace, value = maintenancePinned(workspace));
+		return value;
+	};
 	const result = plan({
 		pressure,
-		sizes: sizes.map((size) => {
-			if (size.category === "compilation-cache") return {
-				...size,
-				blocked: cacheBlocked(size)
-			};
-			if (!size.workspace) return size;
-			const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
-			return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
-		}),
+		sizes: currentSizes,
 		settings,
 		budget,
 		diskSteps: outcome?.status === "ok" ? outcome.reclaimed.filter((step) => devices || step.step !== "idle-devices") : [],
 		protectedRoot: root,
 		scoped: Boolean(process.env.STIM_HOME),
 		projects: Object.keys(loadConfig()?.projects ?? {}).map(canonicalPath),
-		pinned: projectMaintenancePinned,
+		pinned,
 		recentlyUsed: (workspace) => recentUse(workspace, settings)
 	});
 	const merge = (extra) => {
@@ -919,13 +936,13 @@ async function plannedMaintenance(pressure, sizes, settings, { devices = true, s
 		settings,
 		sizes,
 		protectedRoot: root,
-		pinned: projectMaintenancePinned,
+		pinned,
 		now: Date.now()
 	}));
 	if (worktrees) {
 		const planned = await planWorktrees({
 			protectedRoot: root,
-			pinned: projectMaintenancePinned,
+			pinned,
 			now: Date.now()
 		});
 		merge(planned);
@@ -984,4 +1001,4 @@ async function previewMaintenance({ devices = true } = {}) {
 	}
 }
 //#endregion
-export { recentUse as a, worktreePullRequestNote as c, measureDisk as d, measurePressure as f, cacheEntryProtection as i, worktreeRemovalReason as l, sizeScanDeferred as m, previewMaintenance as n, collectWorktreeSweep as o, measureSizes as p, triggeringRoot as r, removeWorktrees as s, plannedMaintenance as t, cacheBlocked as u };
+export { maintenancePinned as a, removeWorktrees as c, cacheBlocked as d, measureDisk as f, sizeScanDeferred as h, cacheEntryProtection as i, worktreePullRequestNote as l, measureSizes as m, previewMaintenance as n, recentUse as o, measurePressure as p, triggeringRoot as r, collectWorktreeSweep as s, plannedMaintenance as t, worktreeRemovalReason as u };