stim 1.20.2 → 1.22.0

package/dist/{artifact-D3czlUvT.mjs → artifact-DJPy518Y.mjs}

@@ -1,22 +1,24 @@
-import { j as ownership_claim_exports } from "./config-BYDxlMY3.mjs";
-import { A as providerDownloadPath, k as prepareProviderDownloadDir, v as waitForSharedBuild } from "./device-lease-BX1sJQ2E.mjs";
-import { x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { _ as stepTimer, i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BTy8hZ0F.mjs";
-import { x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { a as easAuthNote, s as isEasAuthFailureText, t as RESOLVE_TIMEOUT_MS } from "./remote-cache-OyOyVIS3.mjs";
-import { _ as requireLocalBuild, c as offloadPlacement, h as namedBuildMachine, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, p as OffloadRefusal, r as chooseBuildMachine, u as remotePhaseText } from "./client-qQAaXSUs.mjs";
-import { i as skippedMissReason } from "./miss-reason-mKzZ4VvN.mjs";
-import { t as buildPlacementRecord } from "./placement-log-MOfPVgaM.mjs";
-import { t as runArtifactLifecycle } from "./artifact-lifecycle-DzPpBYvK.mjs";
-import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine, t as CCACHE_NOT_RUN } from "./ccache-zdKiYQ3E.mjs";
-import { c as formatDiagnostic } from "./gradle-DSrXb6lG.mjs";
-import { a as PLATFORM, h as displayPath } from "./support-DMTqj3Hm.mjs";
-import { i as AndroidRecipeRefusal } from "./plan-C4TjdPsR.mjs";
+import { h as withDrainingCancellation, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { _ as stepTimer, i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-gwpm28fu.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { Hn as isEasAuthFailureText, Ln as RESOLVE_TIMEOUT_MS, Vn as easAuthNote } from "./budget-Cvwn54qV.mjs";
+import { d as runCancellationSignal, r as cancelledFailure } from "./native-run-NwUuxbkg.mjs";
+import { d as prepareProviderDownloadDir, f as providerDownloadPath } from "./build-cache-Dv7RN200.mjs";
+import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine, t as CCACHE_NOT_RUN } from "./ccache-Btwc36-I.mjs";
+import { c as offloadPlacement, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, r as chooseBuildMachine, u as remotePhaseText } from "./client-OyRoEuSr.mjs";
+import { a as requireLocalBuild, r as namedBuildMachine, t as OffloadRefusal } from "./selection-DSMbWEX2.mjs";
+import { f as formatDiagnostic } from "./react-native-build-Dvd8hC21.mjs";
+import { l as skippedMissReason } from "./prebuild-D4JoEAEs.mjs";
+import { t as buildPlacementRecord } from "./placement-log-BnGgJRRZ.mjs";
+import { n as settleArtifactUploads, t as acquireArtifact } from "./acquire-artifact-Co2k4f7O.mjs";
+import { a as PLATFORM, h as displayPath } from "./support-yUiOjnVY.mjs";
+import { t as AndroidRecipeRefusal } from "./android-project-BCAAmMwz.mjs";
 import { rmSync } from "node:fs";
 import { join } from "node:path";
 import { machineCapacity } from "@stim-cli/core/state";
-import { createWarnOnce, resolveTieredBuild, storeTieredBuild } from "@stim-cli/cache";
 import chalk from "chalk";
+import { PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, buildResolveTimeoutMs, buildUploadTimeoutMs, createWarnOnce, resolveTieredBuild, storeTieredBuild, timeoutFromEnv } from "@stim-cli/cache";
 //#region src/commands/android/artifact.ts
 const FALLBACK_LINES = 5;
 function fail(code, message, remedy, extra = {}) {
@@ -27,10 +29,10 @@ function fail(code, message, remedy, extra = {}) {
 		extra
 	};
 }
-async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOffloadRefusal, buildPlan, cacheProviderConfig, requestedBuildCache, easBuild, androidPackage: initialPackage, record, maxBuilds, progress }, { acquireLock, releaseLock, waitForBuild, easAuth, resolveRemoteBuild, uploadRemoteBuild, loadCacheProviderModule, acquireSlot, releaseSlot, now }) {
+async function acquireAndroidArtifact({ context, root, buildLog, writer, recipe, targetOffloadRefusal, buildPlan, cacheProviderConfig, requestedBuildCache, easBuild, androidPackage: initialPackage, record, maxBuilds, progress }, { acquireLock, releaseLock, waitForBuild, easAuth, resolveRemoteBuild, uploadRemoteBuild, loadCacheProviderModule, acquireSlot, releaseSlot, now }) {
 	const { phase, out, stats, step, miss, hit: lateHit, place, waitingOn, waitingFor } = progress;
 	let fallbackMachine = null;
-	let hereReason = "no remote Mac is paired";
+	let hereReason = "no remote machine is paired";
 	let slotWaitMs;
 	const buildMachine = record.buildMachine ?? "auto";
 	const fallBack = (reason, line = reason, info = {}) => {
@@ -51,7 +53,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		phase("build", `${line} -> building here`);
 	};
 	const { variant, cache: cachePolicy } = buildPlan;
-	const signal = runCancellationSignal() ?? new AbortController().signal;
+	const signal = runCancellationSignal(context) ?? context.signal;
 	const cacheTarget = (key) => ({
 		projectRoot: root,
 		platform: "android",
@@ -63,28 +65,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	let androidPackage = initialPackage;
 	let ccacheActivity = CCACHE_NOT_RUN;
 	let phaseFailure = null;
-	let buildLock = null;
-	const releaseHeldLock = () => {
-		if (!buildLock) return;
-		const held = buildLock;
-		buildLock = null;
-		try {
-			releaseLock(held);
-		} catch (err) {
-			out(phaseLine("build", chalk.dim(`could not release the build lock at ${held.path}: ${err?.message || err}`)));
-		}
-	};
-	let buildSlot = null;
-	const releaseHeldSlot = () => {
-		if (!buildSlot) return;
-		const held = buildSlot;
-		buildSlot = null;
-		try {
-			releaseSlot(held);
-		} catch (err) {
-			out(phaseLine("build", chalk.dim(`could not release the build slot: ${err?.message || err}`)));
-		}
-	};
+	let run;
 	let hash = "";
 	let providerUpload = null;
 	let providerName = null;
@@ -92,7 +73,16 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	const cacheWarn = createWarnOnce((line) => phase("cache", chalk.yellow(line)));
 	const loadTieredProvider = cachePolicy.remote && cacheProviderConfig ? () => providerLoad ??= loadCacheProviderModule({
 		projectRoot: root,
-		config: cacheProviderConfig
+		config: cacheProviderConfig,
+		env: context.env,
+		timeoutMs: timeoutFromEnv(PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, context.env)
+	}).then((loaded) => {
+		if (!loaded.provider || !recipe.providerCache) return loaded;
+		const builds = recipe.providerCache(loaded.provider);
+		return {
+			...loaded,
+			provider: builds ? { builds } : {}
+		};
 	}) : null;
 	let cacheKey = "";
 	let storeHash = "";
@@ -140,7 +130,8 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		record.cacheKey = cacheKey;
 		storeHash = hash;
 		storeKey = cacheKey;
-		const found = await resolveTieredBuild({
+		const found = await withDrainingCancellation(context, signal, () => resolveTieredBuild({
+			timeoutMs: buildResolveTimeoutMs(context.env),
 			local: recipe.cache(),
 			loadProvider: loadTieredProvider,
 			target: {
@@ -149,10 +140,11 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				key: cacheKey
 			},
 			destinationDir: providerDownloadPath(workspaceDir(root)),
-			ensureDestination: prepareProviderDownloadDir,
+			ensureDestination: (dir) => prepareProviderDownloadDir(dir, root),
 			skipRead: !useBuildCache,
-			warn: cacheWarn
-		});
+			warn: cacheWarn,
+			signal
+		}));
 		const cached = found?.tier === "local" ? found.path : null;
 		record.cacheHit = cached ? "local" : false;
 		record.cacheSkipped = !useBuildCache;
@@ -169,13 +161,14 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	let abandonedRemote = false;
 	let uploadPending = null;
 	async function resolveRemoteArtifact() {
-		if (cacheIneligible || !recipe.legacyCache) return;
+		if (cacheIneligible || !recipe.expoCache) return;
 		if (!apkPath) {
-			const loaded = await recipe.legacyCache.load();
+			const loaded = await recipe.expoCache.load();
 			if (loaded?.unavailable) phase("cache", chalk.yellow(`provider not usable: ${loaded.unavailable}`));
 			else if (loaded?.provider) remote = loaded;
 			if (remote?.name === "eas") {
-				const auth = easAuth({
+				const auth = await easAuth({
+					context,
 					projectRoot: root,
 					owner: loaded?.owner || null
 				});
@@ -187,12 +180,13 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		if (remote && useBuildCache) {
 			const remoteTimer = stepTimer(now);
 			const hit = await resolveRemoteBuild({
+				context,
 				logWriter: writer,
 				provider: remote.provider,
 				platform: PLATFORM,
 				projectRoot: root,
 				fingerprintHash: hash,
-				runOptions: recipe.legacyCache?.runOptions ?? null
+				runOptions: recipe.expoCache?.runOptions ?? null
 			});
 			if (hit?.appPath) {
 				let stored = null;
@@ -203,6 +197,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 						overwrite: false
 					}) ?? null;
 				} catch (err) {
+					throwIfCancelled(signal, "build cache backfill");
 					phase("cache", chalk.yellow(`remote hit could not be stored locally: ${err?.message || err}`));
 				}
 				apkPath = stored || hit.appPath;
@@ -224,16 +219,9 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	let releasedWait = null;
 	async function awaitSharedBuild() {
 		if (!useBuildCache) return null;
-		const shared = await waitForSharedBuild({
-			platform: PLATFORM,
+		const shared = await run.claimSharedBuild({
 			key: cacheKey,
 			fingerprint: hash,
-			root,
-			logFile: buildLog,
-			command: "stim android",
-			acquire: acquireLock,
-			wait: waitForBuild,
-			now,
 			phase: (text) => {
 				step("wait");
 				phase("build", text);
@@ -247,7 +235,6 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			phaseFailure = fail(code, message, remedy, { lastBuildStatus: true });
 			throw new AndroidRecipeRefusal(phaseFailure);
 		}
-		buildLock = shared.lock;
 		releasedWait = shared.released;
 		if (shared.hit) {
 			apkPath = shared.hit.path;
@@ -256,26 +243,17 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		}
 		return apkPath;
 	}
-	let swapDir = null;
-	const releaseArtifact = () => {
-		if (!swapDir) return;
-		try {
-			rmSync(swapDir, {
-				recursive: true,
-				force: true
-			});
-			swapDir = null;
-		} catch (error) {
-			out(phaseLine("cleanup", chalk.yellow(`could not remove the temporary APK: ${error.message}`)));
-		}
-	};
 	const installableCachedApk = async (key, cachedPath) => {
 		const prepared = await recipe.materialize(key, cachedPath);
 		if (!prepared) {
 			swapFellBack = true;
 			return null;
 		}
-		swapDir = prepared.directory;
+		if (prepared.directory) run.own(prepared.directory);
+		if (prepared.androidPackage) {
+			androidPackage = prepared.androidPackage;
+			record.bundleId = androidPackage;
+		}
 		return prepared.apkPath;
 	};
 	async function prepareCachedArtifact(cachedPath) {
@@ -316,16 +294,15 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		requireLocalBuild(buildMachine);
 		if (!maxBuilds) return true;
 		try {
-			buildSlot = await acquireSlot({
+			slotWaitMs = (await run.takeBuildSlot({
+				signal,
 				automatic: buildMachine === "auto",
 				max: maxBuilds,
-				root,
-				logFile: buildLog,
 				out,
 				waitingFor: (info) => waitingFor?.(info, "build-slot")
-			});
-			slotWaitMs = buildSlot.slotWaitMs;
+			})).slotWaitMs;
 		} catch (err) {
+			throwIfCancelled(signal, "Android build");
 			requireLocalBuild(buildMachine);
 			const refusal = (0, ownership_claim_exports.claimFailure)(err, "stim android");
 			if (refusal) {
@@ -336,7 +313,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		}
 		return true;
 	}
-	/** Whether this build should leave this Mac, before any machine is asked; null builds here. */
+	/** Whether this build should leave this machine, before any machine is asked; null builds here. */
 	function placeBuild() {
 		if (cacheIneligible && !recipe.offload?.supportsUncachedArtifacts) {
 			if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, cacheIneligible);
@@ -357,6 +334,14 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		});
 		if (!placement.offload) {
 			hereReason = placement.reason;
+			if (placement.code === "this-mac-free" && cachePolicy.read && cachePolicy.remote && (recipe.offload?.uncachedArtifacts || recipe.offload && !recipe.offload.request.native)) return {
+				cacheOnly: true,
+				mode,
+				here,
+				code: placement.code,
+				reason: placement.reason,
+				machines
+			};
 			writer.write(buildPlacementRecord({
 				platform: PLATFORM,
 				buildMachine,
@@ -369,6 +354,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			return null;
 		}
 		return {
+			cacheOnly: false,
 			mode,
 			here,
 			code: placement.code,
@@ -376,17 +362,19 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			machines
 		};
 	}
-	const openOffload = { choice: null };
 	/** Asks the paired machines once the post-mutation key is known; null builds here. */
 	async function chooseMachine(candidate) {
+		const offload = recipe.offload;
 		let asked = [];
 		let target;
 		try {
-			target = recipe.offload.target();
+			target = await offload.target();
 		} catch (error) {
+			if (candidate.cacheOnly) return null;
 			fallBack(error.message);
 			return null;
 		}
+		const request = offload.request;
 		const choice = await chooseBuildMachine({
 			projectRoot: root,
 			target,
@@ -395,9 +383,23 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			note: (line) => phase("build", chalk.dim(`offload: ${line}`)),
 			machines: candidate.machines,
 			selected: buildMachine,
-			onCandidates: (each) => asked = each
+			onCandidates: (each) => asked = each,
+			cacheOnly: candidate.cacheOnly,
+			...cachePolicy.read && cachePolicy.remote && storeHash && !request.native ? { reactNativeArtifact: {
+				fingerprint: storeHash,
+				request
+			} } : {},
+			...cachePolicy.read && cachePolicy.remote && request.native?.provider === "gradle" && request.android.variant ? { gradleArtifact: {
+				sourceDigest: request.native.transfer.digest,
+				inputs: request.native.transfer.declaration,
+				android: {
+					...request.android,
+					variant: request.android.variant
+				}
+			} } : {}
 		});
 		if (typeof choice === "string") {
+			if (candidate.cacheOnly) return null;
 			const only = candidate.machines.length === 1 ? candidate.machines[0].machine : null;
 			if (only && choice.startsWith(`${only}: `)) fallbackMachine = only;
 			fallBack(choice, choice, {
@@ -406,7 +408,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			});
 			return null;
 		}
-		openOffload.choice = choice;
+		run.openOffload(() => closeOffload(choice));
 		writer.write(buildPlacementRecord({
 			platform: PLATFORM,
 			buildMachine,
@@ -421,7 +423,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	}
 	/** Builds on the chosen machine and stores the APK under the post-mutation key; false builds here instead unless a machine was named. */
 	async function compileElsewhere(choice, candidate) {
-		const uncached = Boolean(cacheIneligible && recipe.offload?.supportsUncachedArtifacts);
+		const uncached = Boolean(recipe.offload?.uncachedArtifacts || cacheIneligible && recipe.offload?.supportsUncachedArtifacts);
 		if ((!storeKey || !storeHash) && !uncached) {
 			const reason = "the build fingerprint or cache key is unavailable";
 			if (namedBuildMachine(buildMachine)) fallBack(reason, reason, { machine: choice.machine });
@@ -438,7 +440,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			return false;
 		}
 		const stagingDir = join(workspaceDir(root), "offload", PLATFORM);
-		if (uncached) swapDir = stagingDir;
+		const disownStaging = uncached ? run.own(stagingDir) : null;
 		const outcome = await offloadBuild({
 			choice,
 			expectedFingerprint: uncached ? null : storeHash,
@@ -475,7 +477,6 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				else {
 					stored = outcome.artifactPath;
 					androidPackage = outcome.androidPackage;
-					swapDir = stagingDir;
 				}
 			} else try {
 				stored = await recipe.cache().store({
@@ -487,17 +488,19 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				reason = `could not store the APK: ${err?.message || err}`;
 			}
 		}
-		try {
-			if (!uncached || !stored) {
+		if (!uncached || !stored) {
+			disownStaging?.();
+			try {
 				rmSync(stagingDir, {
 					recursive: true,
 					force: true
 				});
-				if (swapDir === stagingDir) swapDir = null;
-			}
-		} catch {}
+			} catch {}
+		}
+		throwIfCancelled(signal, "offloaded build cache copy");
 		step("compile");
 		if (!outcome.ok || !stored) {
+			if (candidate.cacheOnly) return false;
 			const why = reason ?? "the APK was not stored";
 			fallbackMachine = choice.machine;
 			fallBack(`${choice.machine}: ${why}`, `offload failed: ${why}`, {
@@ -514,6 +517,13 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			return false;
 		}
 		const { timings } = outcome;
+		if (uncached) {
+			record.fingerprint = null;
+			record.cacheKey = null;
+			record.cacheHit = outcome.cacheHit ? "remote" : false;
+			record.cacheSkipped = !outcome.cacheHit;
+		}
+		if (outcome.cacheHit) lateHit();
 		apkPath = stored;
 		handoff = outcome.handoff ?? null;
 		record.builtOn = outcome.machine;
@@ -525,13 +535,13 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			buildMs: timings.totalMs
 		});
 		ccacheActivity = outcome.ccache;
-		phase("build", `built on ${outcome.machine} in ${formatDuration(timings.totalMs)}: offer ${formatDuration(timings.offerMs)}, sync ${formatDuration(timings.syncMs)}, build ${formatDuration(timings.workerMs)}, fetch ${formatDuration(timings.fetchMs)}`);
+		phase("build", `${outcome.cacheHit ? "reused from" : "built on"} ${outcome.machine} in ${formatDuration(timings.totalMs)}: offer ${formatDuration(timings.offerMs)}, sync ${formatDuration(timings.syncMs)}, build ${formatDuration(timings.workerMs)}, fetch ${formatDuration(timings.fetchMs)}`);
 		phase("cache", `compilation cache on ${outcome.machine} ${ccacheActivityLine(ccacheActivity)}`);
 		writer.write({
 			src: "build",
 			level: "info",
 			event: "offload_done",
-			msg: `built on ${outcome.machine}`,
+			msg: `${outcome.cacheHit ? "reused from" : "built on"} ${outcome.machine}`,
 			timings
 		});
 		return true;
@@ -593,7 +603,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			explainMiss(rekeyedBy);
 			step("compile");
 		}
-		if (offload) stats.setPlacement({
+		if (offload && !offload.cacheOnly) stats.setPlacement({
 			decision: "fell-back",
 			slotWaitMs,
 			deviceSlotWaitMs: stats.deviceSlotWaitMs(),
@@ -660,7 +670,8 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		if (cachePolicy.write) {
 			const local = recipe.cache(true);
 			try {
-				const stored = await storeTieredBuild({
+				const stored = await withDrainingCancellation(context, signal, () => storeTieredBuild({
+					timeoutMs: buildUploadTimeoutMs(context.env),
 					local,
 					loadProvider: loadTieredProvider,
 					target: {
@@ -670,91 +681,119 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 					},
 					sourcePath: artifactPath,
 					overwrite: !useBuildCache || swapFellBack,
-					warn: cacheWarn
-				});
-				providerUpload = stored.providerUpload;
+					warn: cacheWarn,
+					signal
+				}));
+				const pending = stored.providerUpload;
+				providerUpload = pending ? withDrainingCancellation(context, signal, () => pending) : null;
+				providerUpload?.catch(() => {});
 				providerName = stored.providerName ?? providerName;
 			} catch (err) {
+				throwIfCancelled(signal, "build cache storage");
 				phase("cache", chalk.yellow(`could not store the build: ${err?.message || err}`));
 			}
 		}
-		if (remote) uploadPending = uploadRemoteBuild({
-			logWriter: writer,
-			provider: remote.provider,
-			platform: PLATFORM,
-			projectRoot: root,
-			fingerprintHash: storeHash,
-			buildPath: artifactPath,
-			runOptions: recipe.legacyCache?.runOptions ?? null
-		});
+		if (remote) {
+			uploadPending = uploadRemoteBuild({
+				context,
+				logWriter: writer,
+				provider: remote.provider,
+				platform: PLATFORM,
+				projectRoot: root,
+				fingerprintHash: storeHash,
+				buildPath: artifactPath,
+				runOptions: recipe.expoCache?.runOptions ?? null
+			});
+			uploadPending.catch(() => {});
+		}
 	}
-	try {
-		apkPath = await runArtifactLifecycle({
-			resolve: async () => {
-				if (!await resolveInitialFingerprint()) throw new AndroidRecipeRefusal(phaseFailure);
-				if (easBuild) return {
-					kind: "ready",
-					artifact: apkPath
-				};
-				await resolveRemoteArtifact();
-				if (apkPath) return {
-					kind: "cached",
-					artifact: apkPath
-				};
-				miss(reasonForMiss([]).reason);
-				return { kind: "miss" };
-			},
-			claim: useBuildCache ? awaitSharedBuild : void 0,
-			reuse: async (cached) => {
-				apkPath = await prepareCachedArtifact(cached);
-				if (apkPath) lateHit();
-				else if (swapFellBack) miss(reasonForMiss([]).reason);
-				return apkPath;
-			},
-			build: {
-				placement: {
-					select: placeBuild,
-					acquire: acquireRemoteArtifact
+	const acquired = await acquireArtifact({
+		platform: PLATFORM,
+		command: "stim android",
+		lifecycle: (driver) => {
+			run = driver;
+			return {
+				resolve: async () => {
+					if (!await resolveInitialFingerprint()) throw new AndroidRecipeRefusal(phaseFailure);
+					if (easBuild) return {
+						kind: "ready",
+						artifact: apkPath
+					};
+					await resolveRemoteArtifact();
+					if (apkPath) return {
+						kind: "cached",
+						artifact: apkPath
+					};
+					miss(reasonForMiss([]).reason);
+					return { kind: "miss" };
 				},
-				admit: async () => {
-					if (!await takeBuildSlot()) throw new AndroidRecipeRefusal(phaseFailure);
+				claim: useBuildCache ? awaitSharedBuild : void 0,
+				reuse: async (cached) => {
+					apkPath = await prepareCachedArtifact(cached);
+					if (apkPath) lateHit();
+					else if (swapFellBack) miss(reasonForMiss([]).reason);
+					return apkPath;
 				},
-				prepare: prepareSource,
-				revalidate: revalidateSource,
-				compile: compileHere,
-				validate: validateCompiled,
-				store: storeArtifact
-			},
-			release: () => {
-				if (openOffload.choice) closeOffload(openOffload.choice);
-				releaseHeldLock();
-				releaseHeldSlot();
-			}
-		});
-	} catch (error) {
-		releaseArtifact();
-		if (error instanceof OffloadRefusal) {
-			const { code, message, remedy } = error;
-			return {
-				ok: false,
-				failure: fail(code, message, remedy, { lastBuildStatus: true }),
-				ccache: ccacheActivity
+				build: {
+					placement: {
+						select: placeBuild,
+						acquire: acquireRemoteArtifact
+					},
+					admit: async () => {
+						if (!await takeBuildSlot()) throw new AndroidRecipeRefusal(phaseFailure);
+					},
+					prepare: prepareSource,
+					revalidate: revalidateSource,
+					compile: compileHere,
+					validate: validateCompiled,
+					store: storeArtifact
+				}
 			};
+		},
+		settleFailed: async () => {
+			await settleArtifactUploads(uploadPending, providerUpload);
+		},
+		refuse: (error) => {
+			if (error instanceof OffloadRefusal) {
+				const { code, message, remedy } = error;
+				return fail(code, message, remedy, { lastBuildStatus: true });
+			}
+			if (error instanceof AndroidRecipeRefusal) return error.failure;
+			const cancelled = cancelledFailure(context, PLATFORM, {
+				code: "STIM_CANCELLED",
+				message: "during app preparation"
+			});
+			return cancelled ? fail(cancelled.code, cancelled.message, cancelled.remedy, { lastBuildStatus: true }) : null;
+		},
+		releaseFailed: (subject, err) => out(phaseLine("build", chalk.dim(`could not release ${subject}: ${err?.message || err}`))),
+		temporaryReleaseFailed: (error) => out(phaseLine("cleanup", chalk.yellow(`could not remove the temporary APK: ${error.message}`)))
+	}, {
+		root,
+		logFile: buildLog,
+		deps: {
+			acquireBuildLock: acquireLock,
+			releaseBuildLock: releaseLock,
+			waitForBuild,
+			acquireBuildSlot: acquireSlot,
+			releaseBuildSlot: releaseSlot,
+			now
 		}
-		if (error instanceof AndroidRecipeRefusal) return {
-			ok: false,
-			failure: error.failure,
-			ccache: ccacheActivity
-		};
-		throw error;
-	}
+	});
+	if (!acquired.ok) return {
+		ok: false,
+		failure: acquired.failure,
+		ccache: ccacheActivity
+	};
 	return {
 		ok: true,
 		artifact: {
-			apkPath,
+			apkPath: acquired.artifact,
 			handoff,
 			androidPackage,
-			release: releaseArtifact,
+			release: async () => {
+				await settleArtifactUploads(providerUpload, uploadPending);
+				acquired.release();
+			},
 			waitedForBuild,
 			ccache: ccacheActivity,
 			uploadPending,

package/dist/artifact-platform-CXcmX_j3.mjs

@@ -0,0 +1,27 @@
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { join } from "node:path";
+//#region src/macos/artifact-platform.ts
+async function validateMacosArtifactPlatform(context, bundle, product, signal) {
+	const binary = join(bundle, "Contents", "MacOS", product);
+	const options = {
+		timeoutMs: 3e4,
+		signal,
+		declareFor: context
+	};
+	const architecture = process.arch === "x64" ? "x86_64" : process.arch;
+	const archs = await getExecutor().runFileAsync("xcrun", [
+		"lipo",
+		"-archs",
+		binary
+	], options);
+	const platform = await getExecutor().runFileAsync("xcrun", [
+		"vtool",
+		"-arch",
+		architecture,
+		"-show-build",
+		binary
+	], options);
+	if (!archs.trim().split(/\s+/).includes(architecture) || !/^\s*platform\s+MACOS\s*$/m.test(platform)) throw new Error("The cached macOS executable does not match this platform and architecture.");
+}
+//#endregion
+export { validateMacosArtifactPlatform as t };