stim 1.19.0 → 1.20.0

package/dist/artifact-DClXJNWx.mjs

@@ -0,0 +1,772 @@
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { A as providerDownloadPath, k as prepareProviderDownloadDir, v as waitForSharedBuild } from "./device-lease-DHOBXGgS.mjs";
+import { x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { _ as stepTimer, i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BjPN99ZB.mjs";
+import { x as runCancellationSignal } from "./tailnet-CoJUb2tB.mjs";
+import { a as easAuthNote, s as isEasAuthFailureText, t as RESOLVE_TIMEOUT_MS } from "./remote-cache-Bsts6f6Y.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-BLy1Pw2V.mjs";
+import { i as skippedMissReason } from "./miss-reason-BPAzZS0r.mjs";
+import { t as buildPlacementRecord } from "./placement-log-reFbjqEr.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-CjHQ5F8g.mjs";
+import { c as formatDiagnostic } from "./gradle-C2OEKCCI.mjs";
+import { a as PLATFORM, h as displayPath } from "./support-CnE_SIjt.mjs";
+import { i as AndroidRecipeRefusal } from "./plan-BDk2AeY_.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";
+//#region src/commands/android/artifact.ts
+const FALLBACK_LINES = 5;
+function fail(code, message, remedy, extra = {}) {
+	return {
+		code,
+		message,
+		remedy,
+		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 }) {
+	const { phase, out, stats, step, miss, hit: lateHit, place, waitingOn, waitingFor } = progress;
+	let fallbackMachine = null;
+	let hereReason = "no remote Mac is paired";
+	let slotWaitMs;
+	const buildMachine = record.buildMachine ?? "auto";
+	const fallBack = (reason, line = reason, info = {}) => {
+		writer.write(buildPlacementRecord({
+			platform: PLATFORM,
+			buildMachine,
+			candidates: info.candidates,
+			event: "placement_fallback",
+			fallback: {
+				code: info.code ?? "fallback",
+				reason,
+				machine: info.machine
+			}
+		}));
+		if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, reason);
+		requireLocalBuild(buildMachine);
+		record.offloadFallback = reason;
+		phase("build", `${line} -> building here`);
+	};
+	const { variant, cache: cachePolicy } = buildPlan;
+	const signal = runCancellationSignal() ?? new AbortController().signal;
+	const cacheTarget = (key) => ({
+		projectRoot: root,
+		platform: "android",
+		key,
+		signal
+	});
+	let useBuildCache = cachePolicy.read;
+	let cacheIneligible = null;
+	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 hash = "";
+	let providerUpload = null;
+	let providerName = null;
+	let providerLoad = null;
+	const cacheWarn = createWarnOnce((line) => phase("cache", chalk.yellow(line)));
+	const loadTieredProvider = cachePolicy.remote && cacheProviderConfig ? () => providerLoad ??= loadCacheProviderModule({
+		projectRoot: root,
+		config: cacheProviderConfig
+	}) : null;
+	let cacheKey = "";
+	let storeHash = "";
+	let storeKey = "";
+	let apkPath = null;
+	let handoff = null;
+	let swapFellBack = false;
+	async function resolveInitialFingerprint() {
+		if (easBuild?.ok) {
+			hash = storeHash = easBuild.fingerprint;
+			cacheKey = storeKey = easBuild.cacheKey;
+			apkPath = easBuild.path;
+			record.fingerprint = hash;
+			record.cacheKey = cacheKey;
+			record.cacheHit = easBuild.cacheHit;
+			record.cacheSkipped = !useBuildCache;
+			providerName = "eas";
+			stats.setCacheKey(cacheKey);
+			return true;
+		}
+		if (useBuildCache) step("cache-lookup");
+		const fingerprintTimer = stepTimer(now);
+		let computed;
+		try {
+			computed = await recipe.identity();
+		} catch (error) {
+			record.cacheSkipped = !useBuildCache;
+			if (error instanceof AndroidRecipeRefusal && error.missReason) record.missReason = error.missReason;
+			throw error;
+		}
+		if ("cacheIneligible" in computed) {
+			cacheIneligible = computed.cacheIneligible;
+			useBuildCache = false;
+			record.fingerprint = null;
+			record.cacheKey = null;
+			record.cacheHit = false;
+			record.cacheSkipped = true;
+			phase("fingerprint", `unavailable: ${cacheIneligible}`);
+			return true;
+		}
+		hash = computed.hash;
+		record.fingerprint = hash;
+		cacheKey = computed.key;
+		stats.setCacheKey(cacheKey);
+		record.cacheKey = cacheKey;
+		storeHash = hash;
+		storeKey = cacheKey;
+		const found = await resolveTieredBuild({
+			local: recipe.cache(),
+			loadProvider: loadTieredProvider,
+			target: {
+				projectRoot: root,
+				platform: PLATFORM,
+				key: cacheKey
+			},
+			destinationDir: providerDownloadPath(workspaceDir(root)),
+			ensureDestination: prepareProviderDownloadDir,
+			skipRead: !useBuildCache,
+			warn: cacheWarn
+		});
+		const cached = found?.tier === "local" ? found.path : null;
+		record.cacheHit = cached ? "local" : false;
+		record.cacheSkipped = !useBuildCache;
+		phase("fingerprint", `${shortHash(hash)} ${cached ? "hit" : "miss"}${useBuildCache ? "" : !requestedBuildCache ? " (--no-build-cache)" : " (cache reuse off in config)"} ${fingerprintTimer()}`);
+		if (found?.tier === "provider") {
+			record.cacheHit = "remote";
+			providerName = found.providerName ?? null;
+			phase("cache", `provider hit (${providerName})${found.storedLocally ? " -> stored locally" : ""}`);
+		}
+		apkPath = found?.path ?? null;
+		return true;
+	}
+	let remote = null;
+	let abandonedRemote = false;
+	let uploadPending = null;
+	async function resolveRemoteArtifact() {
+		if (cacheIneligible || !recipe.legacyCache) return;
+		if (!apkPath) {
+			const loaded = await recipe.legacyCache.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({
+					projectRoot: root,
+					owner: loaded?.owner || null
+				});
+				const authNote = easAuthNote(auth);
+				if (authNote) phase("cache", chalk.yellow(authNote));
+				if (auth?.code === "logged-out") remote = null;
+			}
+		}
+		if (remote && useBuildCache) {
+			const remoteTimer = stepTimer(now);
+			const hit = await resolveRemoteBuild({
+				logWriter: writer,
+				provider: remote.provider,
+				platform: PLATFORM,
+				projectRoot: root,
+				fingerprintHash: hash,
+				runOptions: recipe.legacyCache?.runOptions ?? null
+			});
+			if (hit?.appPath) {
+				let stored = null;
+				try {
+					stored = await recipe.cache().store({
+						...cacheTarget(cacheKey),
+						sourcePath: hit.appPath,
+						overwrite: false
+					}) ?? null;
+				} catch (err) {
+					phase("cache", chalk.yellow(`remote hit could not be stored locally: ${err?.message || err}`));
+				}
+				apkPath = stored || hit.appPath;
+				record.cacheHit = "remote";
+				phase("cache", `remote hit (${remote.name})${stored ? " -> stored locally" : ""} ${remoteTimer()}`);
+			} else if (hit?.timedOut) {
+				abandonedRemote = true;
+				phase("cache", chalk.yellow(`${remote.name} did not answer within ${formatDuration(RESOLVE_TIMEOUT_MS)}; building instead`));
+			} else if (hit?.failed) {
+				const authNote = remote.name === "eas" && isEasAuthFailureText(hit.failed) ? easAuthNote({
+					code: "logged-out",
+					reason: hit.failed
+				}) : null;
+				phase("cache", chalk.yellow(authNote || `${remote.name} could not be used: ${hit.failed}; building instead`));
+			} else phase("cache", `remote miss (${remote.name}) ${remoteTimer()}`);
+		}
+	}
+	let waitedForBuild = null;
+	let releasedWait = null;
+	async function awaitSharedBuild() {
+		if (!useBuildCache) return null;
+		const shared = await waitForSharedBuild({
+			platform: PLATFORM,
+			key: cacheKey,
+			fingerprint: hash,
+			root,
+			logFile: buildLog,
+			command: "stim android",
+			acquire: acquireLock,
+			wait: waitForBuild,
+			now,
+			phase: (text) => {
+				step("wait");
+				phase("build", text);
+			},
+			waitingOn,
+			warn: (text) => phase("build", chalk.yellow(text)),
+			out
+		});
+		if (shared.refusal) {
+			const { code, message, remedy } = shared.refusal;
+			phaseFailure = fail(code, message, remedy, { lastBuildStatus: true });
+			throw new AndroidRecipeRefusal(phaseFailure);
+		}
+		buildLock = shared.lock;
+		releasedWait = shared.released;
+		if (shared.hit) {
+			apkPath = shared.hit.path;
+			record.cacheHit = "local";
+			waitedForBuild = shared.hit.waited;
+		}
+		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;
+		return prepared.apkPath;
+	};
+	async function prepareCachedArtifact(cachedPath) {
+		const prepared = await installableCachedApk(cacheKey, cachedPath);
+		if (!prepared) {
+			record.cacheHit = false;
+			waitedForBuild = null;
+		}
+		return prepared;
+	}
+	function reasonForMiss(rekeyedBy) {
+		if (swapFellBack) return {
+			reason: skippedMissReason("the cached APK could not be reused, so this run built it fresh"),
+			diff: null
+		};
+		if (cacheIneligible) return {
+			reason: skippedMissReason(cacheIneligible),
+			diff: null
+		};
+		if (!useBuildCache) return {
+			reason: skippedMissReason(requestedBuildCache ? "cache reuse off in config" : "cache reuse turned off by --no-build-cache"),
+			diff: null
+		};
+		return recipe.explain(rekeyedBy);
+	}
+	function explainMiss(rekeyedBy) {
+		const explained = reasonForMiss(rekeyedBy);
+		record.missReason = explained.reason;
+		if (explained.diff) writer.write(explained.diff);
+		miss(record.missReason);
+		phase("cache", `miss: ${record.missReason.summary}`);
+		if (record.missReason.kind === "no-baseline") {
+			const line = recipe.untrackedLine();
+			if (line) phase("fingerprint", chalk.dim(line));
+		}
+	}
+	async function takeBuildSlot() {
+		requireLocalBuild(buildMachine);
+		if (!maxBuilds) return true;
+		try {
+			buildSlot = await acquireSlot({
+				automatic: buildMachine === "auto",
+				max: maxBuilds,
+				root,
+				logFile: buildLog,
+				out,
+				waitingFor: (info) => waitingFor?.(info, "build-slot")
+			});
+			slotWaitMs = buildSlot.slotWaitMs;
+		} catch (err) {
+			requireLocalBuild(buildMachine);
+			const refusal = (0, ownership_claim_exports.claimFailure)(err, "stim android");
+			if (refusal) {
+				phaseFailure = fail(refusal.code, refusal.message, refusal.remedy, { lastBuildStatus: true });
+				return false;
+			}
+			phase("build", chalk.yellow(`could not take a build slot: ${err?.message || err}; building anyway`));
+		}
+		return true;
+	}
+	/** Whether this build should leave this Mac, before any machine is asked; null builds here. */
+	function placeBuild() {
+		if (cacheIneligible && !recipe.offload?.supportsUncachedArtifacts) {
+			if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, cacheIneligible);
+			hereReason = cacheIneligible;
+			return null;
+		}
+		const { mode, machines, localEnabled } = buildPlacementCandidates(buildMachine);
+		if (localEnabled && machines.length === 0 && !namedBuildMachine(buildMachine) && buildMachine !== "local") return null;
+		const unsupported = targetOffloadRefusal ?? (recipe.offload ? recipe.offload.unsupported : "this project integration does not support offloaded builds");
+		const here = machineCapacity();
+		const placement = offloadPlacement({
+			mode,
+			localEnabled,
+			machines: machines.length,
+			here,
+			unsupported,
+			selected: buildMachine
+		});
+		if (!placement.offload) {
+			hereReason = placement.reason;
+			writer.write(buildPlacementRecord({
+				platform: PLATFORM,
+				buildMachine,
+				stays: {
+					code: placement.code,
+					reason: placement.reason
+				}
+			}));
+			if (mode !== "off") phase("build", `placement: here (${placement.reason})`);
+			return null;
+		}
+		return {
+			mode,
+			here,
+			code: placement.code,
+			reason: placement.reason,
+			machines
+		};
+	}
+	const openOffload = { choice: null };
+	/** Asks the paired machines once the post-mutation key is known; null builds here. */
+	async function chooseMachine(candidate) {
+		let asked = [];
+		let target;
+		try {
+			target = recipe.offload.target();
+		} catch (error) {
+			fallBack(error.message);
+			return null;
+		}
+		const choice = await chooseBuildMachine({
+			projectRoot: root,
+			target,
+			mode: candidate.mode,
+			here: candidate.here,
+			note: (line) => phase("build", chalk.dim(`offload: ${line}`)),
+			machines: candidate.machines,
+			selected: buildMachine,
+			onCandidates: (each) => asked = each
+		});
+		if (typeof choice === "string") {
+			const only = candidate.machines.length === 1 ? candidate.machines[0].machine : null;
+			if (only && choice.startsWith(`${only}: `)) fallbackMachine = only;
+			fallBack(choice, choice, {
+				code: "no-remote-mac-took-it",
+				candidates: asked
+			});
+			return null;
+		}
+		openOffload.choice = choice;
+		writer.write(buildPlacementRecord({
+			platform: PLATFORM,
+			buildMachine,
+			candidates: asked,
+			chose: {
+				machine: choice.machine,
+				reason: `${candidate.reason}${placementLoad(choice)}`
+			}
+		}));
+		phase("build", `placement: ${choice.machine} (${candidate.reason}${placementLoad(choice)})`);
+		return choice;
+	}
+	/** 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);
+		if ((!storeKey || !storeHash) && !uncached) {
+			const reason = "the build fingerprint or cache key is unavailable";
+			if (namedBuildMachine(buildMachine)) fallBack(reason, reason, { machine: choice.machine });
+			else writer.write(buildPlacementRecord({
+				platform: PLATFORM,
+				buildMachine,
+				event: "placement_fallback",
+				fallback: {
+					code: "fallback",
+					reason,
+					machine: choice.machine
+				}
+			}));
+			return false;
+		}
+		const stagingDir = join(workspaceDir(root), "offload", PLATFORM);
+		if (uncached) swapDir = stagingDir;
+		const outcome = await offloadBuild({
+			choice,
+			expectedFingerprint: uncached ? null : storeHash,
+			request: recipe.offload.request,
+			stagingDir,
+			onPhase: (name, msg) => phase(name, remotePhaseText(name, msg, choice.machine)),
+			onEnter: (name) => {
+				if (name === "compile" || name === "build" || name === "prebuild" || name === "pods") record.builtOn = choice.machine;
+				place({
+					host: choice.machine,
+					phase: name
+				});
+				step(name === "prebuild" ? name : "compile");
+			},
+			onRecord: (entry) => writer.write({
+				...entry,
+				offloadedTo: choice.machine
+			}),
+			note: (line) => phase("build", line)
+		});
+		place(null);
+		let stored = null;
+		let reason = outcome.ok ? null : outcome.reason;
+		if (outcome.ok) {
+			let unchanged = false;
+			try {
+				unchanged = await recipe.offload.unchanged();
+			} catch (error) {
+				reason = error.message;
+			}
+			if (!unchanged) reason ??= "the checkout here changed while it built";
+			else if (uncached) {
+				if (!outcome.androidPackage) reason = "the worker returned no verified APK package";
+				else {
+					stored = outcome.artifactPath;
+					androidPackage = outcome.androidPackage;
+					swapDir = stagingDir;
+				}
+			} else try {
+				stored = await recipe.cache().store({
+					...cacheTarget(storeKey),
+					sourcePath: outcome.artifactPath,
+					overwrite: !useBuildCache
+				}) ?? null;
+			} catch (err) {
+				reason = `could not store the APK: ${err?.message || err}`;
+			}
+		}
+		try {
+			if (!uncached || !stored) {
+				rmSync(stagingDir, {
+					recursive: true,
+					force: true
+				});
+				if (swapDir === stagingDir) swapDir = null;
+			}
+		} catch {}
+		step("compile");
+		if (!outcome.ok || !stored) {
+			const why = reason ?? "the APK was not stored";
+			fallbackMachine = choice.machine;
+			fallBack(`${choice.machine}: ${why}`, `offload failed: ${why}`, {
+				code: "offload-failed",
+				machine: choice.machine
+			});
+			writer.write({
+				src: "build",
+				level: "warn",
+				event: "offload_failed",
+				msg: reason,
+				machine: choice.machine
+			});
+			return false;
+		}
+		const { timings } = outcome;
+		apkPath = stored;
+		handoff = outcome.handoff ?? null;
+		record.builtOn = outcome.machine;
+		record.offloadedTo = outcome.machine;
+		stats.setPlacement({
+			decision: "offloaded",
+			machine: outcome.machine,
+			reason: `${candidate.reason}${placementLoad(choice)}`,
+			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("cache", `compilation cache on ${outcome.machine} ${ccacheActivityLine(ccacheActivity)}`);
+		writer.write({
+			src: "build",
+			level: "info",
+			event: "offload_done",
+			msg: `built on ${outcome.machine}`,
+			timings
+		});
+		return true;
+	}
+	async function prepareSource() {
+		await recipe.prepare(() => miss(reasonForMiss([]).reason, true));
+		return recipe.reconcile();
+	}
+	async function revalidateSource(preparation) {
+		const { identity, rekeyedBy } = preparation;
+		if (preparation.androidPackage) {
+			androidPackage = preparation.androidPackage;
+			record.bundleId = androidPackage;
+		}
+		if (cacheIneligible || !identity) {
+			storeHash = "";
+			storeKey = "";
+			record.fingerprint = null;
+			record.cacheKey = null;
+			return null;
+		}
+		if (identity.key !== storeKey) {
+			storeHash = identity.hash;
+			storeKey = identity.key;
+			record.fingerprint = storeHash;
+			record.cacheKey = storeKey;
+			const late = useBuildCache ? await recipe.cache().resolve({
+				...cacheTarget(storeKey),
+				destinationDir: providerDownloadPath(workspaceDir(root))
+			}) : null;
+			if (late) {
+				const prepared = await installableCachedApk(storeKey, late);
+				if (prepared) {
+					apkPath = prepared;
+					record.cacheHit = "local";
+					lateHit();
+					phase("cache", `hit ${shortHash(storeHash)} (post-${rekeyedBy.join("/")} key)`);
+					if (releasedWait) {
+						waitedForBuild = releasedWait.facts;
+						phase("build", `waited ${formatDuration(waitedForBuild.ms)} for ${releasedWait.who}'s build -> installed from cache -- stim guide lifecycle concurrency`);
+					}
+				}
+			}
+		}
+		return apkPath ? { ready: apkPath } : null;
+	}
+	async function acquireRemoteArtifact(offload, { rekeyedBy, cacheRefusal }) {
+		explainMiss(rekeyedBy);
+		step("compile");
+		if (cacheRefusal) fallBack(cacheRefusal, `offload failed: ${cacheRefusal}`);
+		else {
+			const choice = await chooseMachine(offload);
+			if (choice) await compileElsewhere(choice, offload);
+		}
+		return apkPath ? { ready: apkPath } : null;
+	}
+	async function compileHere(offload, { rekeyedBy }) {
+		if (!offload) {
+			explainMiss(rekeyedBy);
+			step("compile");
+		}
+		if (offload) stats.setPlacement({
+			decision: "fell-back",
+			slotWaitMs,
+			deviceSlotWaitMs: stats.deviceSlotWaitMs(),
+			reason: record.offloadFallback ?? "offload failed",
+			...fallbackMachine ? { machine: fallbackMachine } : {}
+		});
+		else stats.setPlacement({
+			decision: "here",
+			reason: hereReason,
+			slotWaitMs,
+			deviceSlotWaitMs: stats.deviceSlotWaitMs()
+		});
+		requireLocalBuild(buildMachine);
+		record.builtOn = "here";
+		phase("build", `compiling ${variant || "debug"} with Gradle`);
+		const built = await recipe.compile();
+		ccacheActivity = built.ccache ?? CCACHE_UNAVAILABLE;
+		phase("cache", `compilation cache ${ccacheActivityLine(ccacheActivity)}`);
+		if (!built.ok) {
+			const diagnostics = built.diagnostics;
+			for (const diag of diagnostics) writer.write({
+				src: "build",
+				level: "error",
+				event: "gradle_diagnostic",
+				msg: formatDiagnostic(diag)
+			});
+			phase("build", chalk.red(`FAILED after ${formatDuration(built.durationMs)}`));
+			const extracted = diagnostics.map(formatDiagnostic);
+			if (built.truncated > 0) extracted.push(`... and ${built.truncated} more diagnostic(s) in the log`);
+			phaseFailure = fail(built.code, built.reason, diagnostics.find((d) => d.remedy)?.remedy || built.remedy || null, {
+				lastBuildStatus: true,
+				diagnostics: extracted,
+				buildDiagnostics: diagnostics,
+				lines: extracted.length ? [] : tail(built.lastLines),
+				logPath: displayPath(root, buildLog)
+			});
+			throw new AndroidRecipeRefusal(phaseFailure);
+		}
+		apkPath = built.apkPath;
+		if (built.androidPackage) {
+			androidPackage = built.androidPackage;
+			record.bundleId = androidPackage;
+		}
+		stats.setBuildMs(built.durationMs);
+		phase("build", `ok (${formatDuration(built.durationMs)})`);
+		if (built.apkNote) phase("build", chalk.yellow(built.apkNote));
+		return apkPath;
+	}
+	async function validateCompiled() {
+		if (cacheIneligible) return "uncacheable";
+		const identity = await recipe.validate();
+		if (!identity) {
+			record.fingerprint = null;
+			record.cacheKey = null;
+			return "uncacheable";
+		}
+		storeHash = identity.hash;
+		storeKey = identity.key;
+		record.fingerprint = storeHash;
+		record.cacheKey = storeKey;
+		return "cacheable";
+	}
+	async function storeArtifact(artifactPath) {
+		if (cachePolicy.write) {
+			const local = recipe.cache(true);
+			try {
+				const stored = await storeTieredBuild({
+					local,
+					loadProvider: loadTieredProvider,
+					target: {
+						projectRoot: root,
+						platform: PLATFORM,
+						key: storeKey
+					},
+					sourcePath: artifactPath,
+					overwrite: !useBuildCache || swapFellBack,
+					warn: cacheWarn
+				});
+				providerUpload = stored.providerUpload;
+				providerName = stored.providerName ?? providerName;
+			} catch (err) {
+				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
+		});
+	}
+	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
+				},
+				admit: async () => {
+					if (!await takeBuildSlot()) throw new AndroidRecipeRefusal(phaseFailure);
+				},
+				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
+			};
+		}
+		if (error instanceof AndroidRecipeRefusal) return {
+			ok: false,
+			failure: error.failure,
+			ccache: ccacheActivity
+		};
+		throw error;
+	}
+	return {
+		ok: true,
+		artifact: {
+			apkPath,
+			handoff,
+			androidPackage,
+			release: releaseArtifact,
+			waitedForBuild,
+			ccache: ccacheActivity,
+			uploadPending,
+			providerUpload,
+			providerName,
+			remote,
+			abandonedRemote
+		}
+	};
+}
+function tail(lines, n = FALLBACK_LINES) {
+	return (Array.isArray(lines) ? lines : []).slice(-n);
+}
+//#endregion
+export { acquireAndroidArtifact as t };