stim 1.20.2 → 1.22.0

package/dist/{artifact-HSwkIWEQ.mjs → artifact-8EY8SAPw.mjs}

@@ -1,30 +1,32 @@
-import { j as ownership_claim_exports } from "./config-BYDxlMY3.mjs";
-import { A as providerDownloadPath, j as providerUploadOutcome, 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 { S as compilationCacheActivityLine, _ as COMPILATION_CACHE_NOT_RUN } from "./toolchain-DxSsNssu.mjs";
-import { S as xcodeFailureReport, p as printDiagnostics } from "./support-CwjbFs9H.mjs";
-import { r as finishIosUpload, t as IosRecipeRefusal } from "./ios-project-K9hY_Jab.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, p as providerUploadOutcome } from "./build-cache-Dv7RN200.mjs";
+import { o as compilationCacheActivityLine, t as COMPILATION_CACHE_NOT_RUN } from "./xcode-BXn9-xYx.mjs";
+import { _ as clearCorruptCompilationCache, c as offloadPlacement, g as COMPILATION_CACHE_CORRUPT, 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 { S as xcodeFailureReport, p as printDiagnostics } from "./support-CNioewsd.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 { r as finishIosUpload, t as IosRecipeRefusal } from "./ios-project-CZhKODF3.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/ios/artifact.ts
 const PROVIDER_SKIPPED_ON_DEVICE = "a device build is local-tier only: its cache key names the iphoneos slice, and a remote or provider entry is keyed for the simulator";
 function fail(failure) {
 	throw new IosRecipeRefusal(failure);
 }
-async function acquireIosArtifact({ root, logFile, recipe, physical, configuration, buildMachine = "auto", cache, easBuild, maxBuilds, progress }, d) {
+async function acquireIosArtifact({ context, root, logFile, recipe, physical, configuration, buildMachine = "auto", cache, easBuild, maxBuilds, progress }, d) {
 	const { phase, note, logWriter, stats, step, miss, hit: lateHit, place, waitingOn, waitingFor } = progress;
 	const cachePolicy = cache.policy;
-	const signal = runCancellationSignal() ?? new AbortController().signal;
+	const signal = runCancellationSignal(context) ?? context.signal;
 	const cacheTarget = (key) => ({
 		projectRoot: root,
 		platform: "ios",
@@ -35,40 +37,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	let cacheIneligible = null;
 	const cacheProviderConfig = cache.providerConfig;
 	let compilationCache = COMPILATION_CACHE_NOT_RUN;
-	const temporaryDirs = /* @__PURE__ */ new Set();
-	const releaseArtifact = () => {
-		for (const directory of temporaryDirs) {
-			try {
-				rmSync(directory, {
-					recursive: true,
-					force: true
-				});
-			} catch {}
-			temporaryDirs.delete(directory);
-		}
-	};
-	let buildLock = null;
-	const releaseLock = () => {
-		if (!buildLock) return;
-		const held = buildLock;
-		buildLock = null;
-		try {
-			d.releaseBuildLock(held);
-		} catch (e) {
-			note(chalk.dim(`Could not release the build lock at ${held.path}: ${e?.message || e}`));
-		}
-	};
-	let buildSlot = null;
-	const releaseSlot = () => {
-		if (!buildSlot) return;
-		const held = buildSlot;
-		buildSlot = null;
-		try {
-			d.releaseBuildSlot(held);
-		} catch (e) {
-			note(chalk.dim(`Could not release the build slot: ${e?.message || e}`));
-		}
-	};
+	let run;
 	let fingerprint = "";
 	let cacheKey = "";
 	let storeHash = null;
@@ -80,7 +49,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	let handoff = null;
 	let offloadFallback = null;
 	let fallbackMachine = null;
-	let hereReason = "no remote Mac is paired";
+	let hereReason = "no remote machine is paired";
 	let slotWaitMs;
 	let builtOn;
 	const fallBack = (reason, line = reason, info = {}) => {
@@ -104,7 +73,6 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		};
 		phase("build", `${line} -> building here`);
 	};
-	const openOffload = { choice: null };
 	let remote = null;
 	let abandonedRemote = false;
 	let uploadPending = null;
@@ -114,7 +82,9 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	const cacheWarn = createWarnOnce((line) => note(chalk.yellow(phaseLine("cache", line))));
 	const loadProvider = cachePolicy.remote && cacheProviderConfig && !physical ? () => providerLoad ??= d.loadCacheProvider({
 		projectRoot: root,
-		config: cacheProviderConfig
+		config: cacheProviderConfig,
+		env: context.env,
+		timeoutMs: timeoutFromEnv(PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, context.env)
 	}) : null;
 	if (cacheProviderConfig && physical) note(chalk.dim(phaseLine("cache", PROVIDER_SKIPPED_ON_DEVICE)));
 	let waitedForBuild = null;
@@ -130,7 +100,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			cacheHit = easBuild.cacheHit;
 			providerName = "eas";
 			stats.setCacheKey(cacheKey);
-			recipe.validateExternal(appPath);
+			await recipe.validateExternal(appPath);
 			return;
 		}
 		if (useBuildCache) step("cache-lookup");
@@ -147,7 +117,8 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		stats.setCacheKey(cacheKey);
 		storeHash = fingerprint;
 		storeKey = cacheKey;
-		const found = await resolveTieredBuild({
+		const found = await withDrainingCancellation(context, signal, () => resolveTieredBuild({
+			timeoutMs: buildResolveTimeoutMs(context.env),
 			local: recipe.cache(),
 			loadProvider,
 			target: {
@@ -156,10 +127,11 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 				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;
 		cacheHit = cached ? "local" : false;
 		phase("fingerprint", `${shortHash(fingerprint)} ${cached ? "hit" : "miss"}${useBuildCache ? "" : cache.disabledByFlag ? " (--no-build-cache)" : " (cache reuse off in config)"} ${fingerprintTimer()}`);
@@ -171,13 +143,14 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		appPath = found?.path ?? null;
 	}
 	async function resolveRemoteArtifact() {
-		if (cacheIneligible || !recipe.legacyCache) return null;
+		if (cacheIneligible || !recipe.expoCache) return null;
 		if (!appPath) {
-			const loaded = await recipe.legacyCache.load();
+			const loaded = await recipe.expoCache.load();
 			if (loaded?.unavailable) note(chalk.yellow(phaseLine("cache", `provider not usable: ${loaded.unavailable}`)));
 			else if (loaded?.provider) remote = loaded;
 			if (remote?.name === "eas") {
-				const auth = d.checkEasAuth({
+				const auth = await d.checkEasAuth({
+					context,
 					projectRoot: root,
 					owner: loaded?.owner || null
 				});
@@ -189,12 +162,13 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		if (remote && useBuildCache) {
 			const remoteTimer = stepTimer(d.now);
 			const hit = await d.resolveRemote({
+				context,
 				logWriter: logWriter(),
 				provider: remote.provider,
 				platform: "ios",
 				projectRoot: root,
 				fingerprintHash: fingerprint,
-				runOptions: recipe.legacyCache?.runOptions ?? null
+				runOptions: recipe.expoCache?.runOptions ?? null
 			});
 			if (hit?.appPath) {
 				let stored = null;
@@ -205,6 +179,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 						overwrite: false
 					}) ?? null;
 				} catch (e) {
+					throwIfCancelled(signal, "build cache backfill");
 					note(chalk.yellow(phaseLine("cache", `remote hit could not be stored locally: ${e?.message || e}`)));
 				}
 				appPath = stored || hit.appPath;
@@ -225,16 +200,9 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	}
 	async function awaitSharedBuild() {
 		if (!useBuildCache || appPath) return;
-		const shared = await waitForSharedBuild({
-			platform: "ios",
+		const shared = await run.claimSharedBuild({
 			key: cacheKey,
 			fingerprint,
-			root,
-			logFile,
-			command: "stim ios",
-			acquire: d.acquireBuildLock,
-			wait: d.waitForBuild,
-			now: d.now,
 			phase: (text) => {
 				step("wait");
 				phase("build", text);
@@ -252,7 +220,6 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 				cacheSkipped: !useBuildCache
 			}
 		});
-		buildLock = shared.lock;
 		releasedWait = shared.released;
 		if (shared.hit) {
 			appPath = shared.hit.path;
@@ -263,7 +230,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	const installableCachedApp = async (path) => {
 		const prepared = await recipe.materialize(path, {
 			fresh: false,
-			ownTemporary: (directory) => temporaryDirs.add(directory)
+			ownTemporary: (directory) => run.own(directory)
 		});
 		if (!prepared) swapFellBack = true;
 		return prepared;
@@ -321,16 +288,15 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		requireLocalBuild(buildMachine);
 		if (!maxBuilds) return;
 		try {
-			buildSlot = await d.acquireBuildSlot({
+			slotWaitMs = (await run.takeBuildSlot({
+				signal,
 				automatic: buildMachine === "auto",
 				max: maxBuilds,
-				root,
-				logFile,
 				out: note,
 				waitingFor: (info) => waitingFor?.(info, "build-slot")
-			});
-			slotWaitMs = buildSlot.slotWaitMs;
+			})).slotWaitMs;
 		} catch (e) {
+			throwIfCancelled(signal, "iOS build");
 			requireLocalBuild(buildMachine);
 			const refusal = (0, ownership_claim_exports.claimFailure)(e, "stim ios");
 			if (refusal) fail({
@@ -342,8 +308,8 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			note(chalk.yellow(phaseLine("build", `could not take a build slot: ${e?.message || e}; building anyway`)));
 		}
 	}
-	/** Whether this build should leave this Mac, before any machine is asked; null builds here. */
-	function placeBuild() {
+	/** Whether this build should leave this machine, before any machine is asked; null builds here. */
+	async function placeBuild() {
 		if (cacheIneligible) {
 			if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, cacheIneligible);
 			hereReason = cacheIneligible;
@@ -354,7 +320,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		const { runtime, unsupported } = mode === "off" && !namedBuildMachine(buildMachine) ? {
 			runtime: null,
 			unsupported: null
-		} : recipe.offload?.context() ?? {
+		} : await recipe.offload?.context() ?? {
 			runtime: null,
 			unsupported: "this project integration does not support offloaded builds"
 		};
@@ -369,6 +335,15 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		});
 		if (!placement.offload) {
 			hereReason = placement.reason;
+			if (placement.code === "this-mac-free" && runtime && useBuildCache && cachePolicy.remote && recipe.offload !== void 0) return {
+				cacheOnly: true,
+				mode,
+				here,
+				code: placement.code,
+				reason: placement.reason,
+				runtime,
+				machines
+			};
 			logWriter().write(buildPlacementRecord({
 				platform: "ios",
 				buildMachine,
@@ -381,6 +356,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			return null;
 		}
 		return {
+			cacheOnly: false,
 			mode,
 			here,
 			code: placement.code,
@@ -391,18 +367,30 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	}
 	/** Asks the paired machines once the post-mutation key is known; null builds here. */
 	async function chooseMachine(candidate) {
+		const offload = recipe.offload;
+		if (!offload) return null;
 		let asked = [];
 		const choice = await chooseBuildMachine({
 			projectRoot: root,
-			target: recipe.offload.target(candidate.runtime),
+			target: await offload.target(candidate.runtime),
 			mode: candidate.mode,
 			here: candidate.here,
 			note: (line) => note(chalk.dim(phaseLine("build", `offload: ${line}`))),
 			machines: candidate.machines,
 			selected: buildMachine,
-			onCandidates: (each) => asked = each
+			onCandidates: (each) => asked = each,
+			cacheOnly: candidate.cacheOnly,
+			...useBuildCache && cachePolicy.remote && storeHash && !offload.request(candidate.runtime).native ? { reactNativeArtifact: {
+				fingerprint: storeHash,
+				request: offload.request(candidate.runtime)
+			} } : {},
+			...useBuildCache && cachePolicy.remote && storeHash && storeKey && offload.request(candidate.runtime).native?.provider === "xcode" ? { artifact: {
+				fingerprint: storeHash,
+				cacheKey: storeKey
+			} } : {}
 		});
 		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, {
@@ -411,7 +399,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			});
 			return null;
 		}
-		openOffload.choice = choice;
+		run.openOffload(() => closeOffload(choice));
 		logWriter().write(buildPlacementRecord({
 			platform: "ios",
 			buildMachine,
@@ -479,13 +467,22 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 				force: true
 			});
 		} catch {}
+		throwIfCancelled(signal, "offloaded build cache copy");
 		step("compile");
 		const prepared = stored ? await installableCachedApp(stored) : null;
 		if (!outcome.ok || !prepared) {
 			const why = reason ?? "the stored app is not installable";
+			if (candidate.cacheOnly) return false;
 			fallbackMachine = choice.machine;
+			const corrupt = outcome.ok ? void 0 : outcome.compilationCacheCorrupt;
+			if (corrupt !== void 0 && namedBuildMachine(buildMachine)) fail({
+				code: COMPILATION_CACHE_CORRUPT,
+				message: `${choice.machine}: ${corrupt}`,
+				remedy: `Run the same command again. If the message says Stim did not empty the cache on ${choice.machine}, rerun with --remote-build local to build here.`,
+				build: buildFailure
+			});
 			fallBack(`${choice.machine}: ${why}`, `offload failed: ${why}`, {
-				code: "offload-failed",
+				code: corrupt === void 0 ? "offload-failed" : COMPILATION_CACHE_CORRUPT,
 				machine: choice.machine
 			});
 			logWriter().write({
@@ -499,6 +496,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		}
 		const { timings } = outcome;
 		appPath = prepared;
+		if (outcome.cacheHit) cacheHit = "remote";
 		builtOn = outcome.machine;
 		offloadedTo = outcome.machine;
 		handoff = outcome.handoff ?? null;
@@ -508,14 +506,14 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			reason: `${candidate.reason}${placementLoad(choice)}`,
 			buildMs: timings.totalMs
 		});
-		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 artifact 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)}`);
 		compilationCache = outcome.compilationCache;
 		phase("cache", `compilation cache on ${outcome.machine} ${compilationCacheActivityLine(compilationCache)}`);
 		logWriter().write({
 			src: "build",
 			level: "info",
 			event: "offload_done",
-			msg: `built on ${outcome.machine}`,
+			msg: `${outcome.cacheHit ? "reused artifact from" : "built on"} ${outcome.machine}`,
 			timings
 		});
 		return true;
@@ -575,7 +573,7 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 	async function compileHere(offload, { rekeyedBy }) {
 		if (!offload) explainMiss(rekeyedBy);
 		step("compile");
-		if (offload) stats.setPlacement({
+		if (offload && !offload.cacheOnly) stats.setPlacement({
 			decision: "fell-back",
 			slotWaitMs,
 			deviceSlotWaitMs: stats.deviceSlotWaitMs(),
@@ -601,9 +599,12 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		if (!result.ok) {
 			phase("build", `FAILED after ${formatDuration(result.durationMs)}`);
 			printDiagnostics(note, result);
-			const report = xcodeFailureReport(result, logFile);
-			fail({
+			const report = result.compilationCacheCorruption ? await clearCorruptCompilationCache(result.compilationCacheCorruption, root) : {
 				code: result.code,
+				...xcodeFailureReport(result, logFile)
+			};
+			fail({
+				code: report.code,
 				message: report.message,
 				remedy: report.remedy,
 				logPath: logFile,
@@ -620,30 +621,38 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 		return appPath;
 	}
 	async function storeArtifact(artifactPath) {
-		if (storeKey && cachePolicy.write) try {
-			const stored = await storeTieredBuild({
-				local: recipe.cache(),
-				loadProvider,
-				target: {
-					projectRoot: root,
-					platform: "ios",
-					key: storeKey
-				},
-				sourcePath: artifactPath,
-				overwrite: !useBuildCache || swapFellBack,
-				warn: cacheWarn
-			});
-			providerUpload = stored.providerUpload;
-			providerName = stored.providerName ?? providerName;
-		} catch (e) {
-			note(chalk.yellow(`Could not store the build in the shared cache: ${e?.message || e}`));
+		if (storeKey && cachePolicy.write) {
+			const key = storeKey;
+			try {
+				const stored = await withDrainingCancellation(context, signal, () => storeTieredBuild({
+					timeoutMs: buildUploadTimeoutMs(context.env),
+					local: recipe.cache(),
+					loadProvider,
+					target: {
+						projectRoot: root,
+						platform: "ios",
+						key
+					},
+					sourcePath: artifactPath,
+					overwrite: !useBuildCache || swapFellBack,
+					warn: cacheWarn,
+					signal
+				}));
+				const pending = stored.providerUpload;
+				providerUpload = pending ? withDrainingCancellation(context, signal, () => pending) : null;
+				providerUpload?.catch(() => {});
+				providerName = stored.providerName ?? providerName;
+			} catch (e) {
+				throwIfCancelled(signal, "build cache storage");
+				note(chalk.yellow(`Could not store the build in the shared cache: ${e?.message || e}`));
+			}
 		}
 	}
 	async function finishArtifact(artifactPath) {
 		let installPath = artifactPath;
 		const prepared = await recipe.materialize(installPath, {
 			fresh: true,
-			ownTemporary: (directory) => temporaryDirs.add(directory)
+			ownTemporary: (directory) => run.own(directory)
 		});
 		if (!prepared) fail({
 			code: "STIM_INSTALL_FAILED",
@@ -655,76 +664,128 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			}
 		});
 		installPath = prepared;
-		if (remote && !physical && storeHash) uploadPending = d.uploadRemote({
-			logWriter: logWriter(),
-			provider: remote.provider,
-			platform: "ios",
-			projectRoot: root,
-			fingerprintHash: storeHash,
-			buildPath: installPath,
-			runOptions: recipe.legacyCache?.runOptions ?? null
-		});
+		if (remote && !physical && storeHash) {
+			uploadPending = d.uploadRemote({
+				context,
+				logWriter: logWriter(),
+				provider: remote.provider,
+				platform: "ios",
+				projectRoot: root,
+				fingerprintHash: storeHash,
+				buildPath: installPath,
+				runOptions: recipe.expoCache?.runOptions ?? null
+			});
+			uploadPending.catch(() => {});
+		}
 		return installPath;
 	}
-	let transferred = false;
-	try {
-		appPath = await runArtifactLifecycle({
-			resolve: async () => {
-				await resolveInitialFingerprint();
-				if (easBuild) return {
-					kind: "ready",
-					artifact: appPath
-				};
-				remote = await resolveRemoteArtifact();
-				if (appPath) return {
-					kind: "cached",
-					artifact: appPath
-				};
-				miss(reasonForMiss([]).reason);
-				return { kind: "miss" };
-			},
-			claim: useBuildCache ? async () => {
-				await awaitSharedBuild();
-				return appPath;
-			} : void 0,
-			reuse: async (cached) => {
-				appPath = await prepareCachedArtifact(cached);
-				if (appPath) lateHit();
-				else if (swapFellBack) miss(reasonForMiss([]).reason);
-				return appPath;
-			},
-			build: {
-				placement: {
-					select: () => {
-						buildFailure = {
-							fingerprint,
-							cacheKey,
-							cacheHit,
-							cacheSkipped: !useBuildCache,
-							buildMachine
-						};
-						return placeBuild();
-					},
-					acquire: acquireRemoteArtifact
+	const acquired = await acquireArtifact({
+		platform: "ios",
+		command: "stim ios",
+		lifecycle: (driver) => {
+			run = driver;
+			return {
+				resolve: async () => {
+					await resolveInitialFingerprint();
+					if (easBuild) return {
+						kind: "ready",
+						artifact: appPath
+					};
+					remote = await resolveRemoteArtifact();
+					if (appPath) return {
+						kind: "cached",
+						artifact: appPath
+					};
+					miss(reasonForMiss([]).reason);
+					return { kind: "miss" };
 				},
-				admit: takeBuildSlot,
-				prepare: prepareSource,
-				revalidate: revalidateSource,
-				compile: compileHere,
-				validate: async () => {
-					await settleStoreKeyAfterCompile();
-					return storeKey ? "cacheable" : "uncacheable";
+				claim: useBuildCache ? async () => {
+					await awaitSharedBuild();
+					return appPath;
+				} : void 0,
+				reuse: async (cached) => {
+					appPath = await prepareCachedArtifact(cached);
+					if (appPath) lateHit();
+					else if (swapFellBack) miss(reasonForMiss([]).reason);
+					return appPath;
 				},
-				store: storeArtifact,
-				finish: finishArtifact
-			},
-			release: () => {
-				if (openOffload.choice) closeOffload(openOffload.choice);
-				releaseLock();
-				releaseSlot();
-			}
-		});
-		const artifact = {
+				build: {
+					placement: {
+						select: () => {
+							buildFailure = {
+								fingerprint,
+								cacheKey,
+								cacheHit,
+								cacheSkipped: !useBuildCache,
+								buildMachine
+							};
+							return placeBuild();
+						},
+						acquire: acquireRemoteArtifact
+					},
+					admit: takeBuildSlot,
+					prepare: prepareSource,
+					revalidate: revalidateSource,
+					compile: compileHere,
+					validate: async () => {
+						await settleStoreKeyAfterCompile();
+						return storeKey ? "cacheable" : "uncacheable";
+					},
+					store: storeArtifact,
+					finish: finishArtifact
+				}
+			};
+		},
+		settleFailed: async () => {
+			await settleArtifactUploads(uploadPending, providerUpload);
+		},
+		refuse: (error) => {
+			if (error instanceof OffloadRefusal) return {
+				code: error.code,
+				message: error.message,
+				remedy: error.remedy,
+				build: {
+					...buildFailure,
+					buildMachine,
+					...builtOn ? { builtOn } : {}
+				}
+			};
+			if (error instanceof IosRecipeRefusal) return {
+				...error.failure,
+				build: {
+					...buildFailure,
+					...error.failure.build
+				}
+			};
+			const cancelled = cancelledFailure(context, "ios", {
+				code: "STIM_CANCELLED",
+				message: "during app preparation"
+			});
+			return cancelled ? {
+				...cancelled,
+				build: {
+					...buildFailure,
+					buildMachine,
+					...builtOn ? { builtOn } : {}
+				}
+			} : null;
+		},
+		releaseFailed: (subject, e) => note(chalk.dim(`Could not release ${subject}: ${e?.message || e}`)),
+		temporaryReleaseFailed: () => {}
+	}, {
+		root,
+		logFile,
+		deps: d
+	});
+	if (!acquired.ok) return {
+		ok: false,
+		failure: acquired.failure,
+		compilationCache
+	};
+	appPath = acquired.artifact;
+	return {
+		ok: true,
+		artifact: {
 			handoff,
 			path: appPath,
 			bundleId,
@@ -755,53 +816,19 @@ async function acquireIosArtifact({ root, logFile, recipe, physical, configurati
 			},
 			completeUploads: async () => {
 				const uploadWasAbandoned = await finishIosUpload(uploadPending, remote, phase, note);
-				const outcome = providerUploadOutcome(providerUpload ? await providerUpload : null, providerName);
+				const outcome = providerUploadOutcome(providerUpload ? await providerUpload : null, providerName, context.env);
 				if (outcome) {
 					if (outcome.warn) note(chalk.yellow(phaseLine("cache", outcome.line)));
 					else phase("cache", outcome.line);
 				}
 				return abandonedRemote || uploadWasAbandoned;
 			},
-			release: releaseArtifact
-		};
-		transferred = true;
-		return {
-			ok: true,
-			artifact
-		};
-	} catch (error) {
-		if (error instanceof OffloadRefusal) {
-			const refusal = error;
-			return {
-				ok: false,
-				failure: {
-					code: refusal.code,
-					message: refusal.message,
-					remedy: refusal.remedy,
-					build: {
-						...buildFailure,
-						buildMachine,
-						...builtOn ? { builtOn } : {}
-					}
-				},
-				compilationCache
-			};
+			release: async () => {
+				await settleArtifactUploads(providerUpload, uploadPending);
+				acquired.release();
+			}
 		}
-		if (error instanceof IosRecipeRefusal) return {
-			ok: false,
-			failure: {
-				...error.failure,
-				build: {
-					...buildFailure,
-					...error.failure.build
-				}
-			},
-			compilationCache
-		};
-		throw error;
-	} finally {
-		if (!transferred) releaseArtifact();
-	}
+	};
 }
 //#endregion
 export { acquireIosArtifact as t };