stim 1.21.0 → 1.22.0

package/dist/offload-worker.mjs

@@ -1,32 +1,200 @@
-import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { d as workspaceDir, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
-import { k as writeConfigSetting } from "./config-CYcBF478.mjs";
+import { k as writeConfigSetting } from "./config-DlrsduwG.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { d as androidLayoutSetting, y as iosProjectDirSetting } from "./settings-CsJDEXgK.mjs";
-import { t as git } from "./git-C3iTsJaZ.mjs";
-import { f as projectRegistry, g as selectNativeXcodeProject } from "./project-BZNjmW_8.mjs";
+import { o as git, s as gitAsync } from "./operation-exec-BW0em61G.mjs";
+import { d as androidLayoutSetting, y as iosProjectDirSetting } from "./settings-C7O8A6ZI.mjs";
+import { f as projectRegistry, g as selectNativeXcodeProject } from "./project-wM_XFTvE.mjs";
 import { o as parseNdjsonText } from "./ndjson-CgE_o3Dl.mjs";
-import { Fn as processContext } from "./budget-Bs6SxxzO.mjs";
-import { l as fingerprintProject, m as refingerprintAfterMutation } from "./build-cache-DmyR9Zzc.mjs";
-import { n as CCACHE_UNAVAILABLE, o as resolveCcache } from "./ccache-BJRZ9pG3.mjs";
-import { m as clearCorruptCompilationCache, p as COMPILATION_CACHE_CORRUPT } from "./client-UXD70ZbM.mjs";
-import { _ as runPodInstall, d as workerToolchain, m as readPodState, p as podsAreStale } from "./toolchain-Hp9sCpK4.mjs";
-import { r as manifestDigest } from "./native-inputs-TRTTTRxt.mjs";
-import { f as verifyNativeTransfer, i as nativeGradleOutputs, n as gradleStateDirectories, o as validateGradleManifest, s as verifyGradleTransfer, t as gradleOffloadInputs } from "./native-gradle-inputs-Bep9JcSF.mjs";
-import { n as buildAndroid, o as gradlewPath, r as buildIos, u as assembleTaskFor } from "./react-native-build-rhk4smwQ.mjs";
-import { f as podAction } from "./support-Dlu37g6H.mjs";
-import { n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-uD_ipCxF.mjs";
-import { n as buildAndroidOperation, t as buildIosOperation } from "./build-CoPzQRNw.mjs";
-import { r as stageBundle, t as resolveBundleExtras } from "./stage-BIS0ydsV.mjs";
-import { t as logLines } from "./run-D23HmJMs.mjs";
-import { r as nativeXcodeMetadataDirectories } from "./native-xcode-inputs-CB2iQeWq.mjs";
+import { Fn as processContext } from "./budget-Cvwn54qV.mjs";
+import { l as fingerprintProject, m as refingerprintAfterMutation } from "./build-cache-Dv7RN200.mjs";
+import { n as CCACHE_UNAVAILABLE, o as resolveCcache } from "./ccache-Btwc36-I.mjs";
+import { _ as clearCorruptCompilationCache, f as reactNativeArtifactReceipt, g as COMPILATION_CACHE_CORRUPT, m as reactNativeBuildQuery, p as reactNativeArtifactToolchain } from "./client-OyRoEuSr.mjs";
+import { f as workerToolchain, h as readPodState, i as availableIphone, m as podsAreStale, v as runPodInstall } from "./toolchain-DpJMHq0n.mjs";
+import { n as fingerprintNativeInputs, r as manifestDigest } from "./native-inputs-TRTTTRxt.mjs";
+import { a as sourceManifest, o as verifyNativeTransfer } from "./native-source-Y0yLhFyQ.mjs";
+import { i as nativeGradleOutputs, n as gradleStateDirectories, o as validateGradleManifest, s as verifyGradleTransfer, t as gradleOffloadInputs } from "./native-gradle-inputs-Dnh84Zbd.mjs";
+import { n as buildAndroid, o as gradlewPath, r as buildIos, u as assembleTaskFor } from "./react-native-build-Dvd8hC21.mjs";
+import { f as podAction } from "./support-CNioewsd.mjs";
+import { i as runPrebuild, r as recordPrebuild, t as planPrebuild } from "./prebuild-D4JoEAEs.mjs";
+import { g as dumpApkManifest, p as apkPackage } from "./support-yUiOjnVY.mjs";
+import { n as buildAndroidOperation, t as buildIosOperation } from "./build-CabC3G23.mjs";
+import { i as stageBundle, n as resolveBundleExtras } from "./stage-Bps5oius.mjs";
+import { t as logLines } from "./run-DidHghD1.mjs";
+import { r as nativeXcodeMetadataDirectories } from "./native-xcode-inputs-D_VOfFL7.mjs";
+import { n as swiftpmArtifactInputs, r as swiftpmArtifactSnapshot, t as readSwiftpmArtifactToolchain } from "./swiftpm-artifact-inputs-DFcGsXDP.mjs";
+import { a as nativeGradleWorkerArtifactIdentity, i as nativeGradleArtifactSnapshotFromReceipt, o as nativeGradleWorkerScope } from "./native-gradle-artifact-inputs-DHFnmrVf.mjs";
 import { createHash } from "node:crypto";
 import { chmodSync, constants, copyFileSync, cpSync, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, sep } from "node:path";
-import { withAmbientContext } from "@stim-cli/core";
+import { isDeepStrictEqual } from "node:util";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { dependencyInstall, withAmbientContext } from "@stim-cli/core";
 import { isJsonObject, windowsShortDir, windowsShortDirKey } from "@stim-cli/core/state";
+import { realpath } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
+//#region src/offload/swiftpm-artifact.ts
+async function readSwiftpmWorkerToolchain(context, cwd) {
+	const commandPath = async (name) => {
+		const path = getExecutor().findExecutable(name, {
+			cwd,
+			env: context.env
+		});
+		if (!path) throw new Error(`The SwiftPM tool ${name} is unavailable.`);
+		return realpath(path);
+	};
+	const [selected, xcrun, xcodebuild] = await Promise.all([
+		commandPath("swift"),
+		commandPath("xcrun"),
+		commandPath("xcodebuild")
+	]);
+	const compiler = await realpath(await getExecutor().runFileAsync("/usr/bin/xcrun", ["--find", "swift"], {
+		cwd,
+		timeoutMs: 3e4
+	}));
+	const sdk = await realpath(context.env.SDKROOT ?? context.env.SWIFTPM_SDKROOT_macosx ?? await getExecutor().runFileAsync("/usr/bin/xcrun", [
+		"--sdk",
+		"macosx",
+		"--show-sdk-path"
+	], {
+		cwd,
+		timeoutMs: 3e4
+	}));
+	const overrides = {};
+	for (const variable of ["SWIFT_EXEC", "SWIFT_EXEC_MANIFEST"]) {
+		const command = context.env[variable];
+		if (!command) continue;
+		const version = await getExecutor().runFileAsync(command, ["--version"], {
+			cwd,
+			timeoutMs: 3e4,
+			declareFor: context
+		});
+		if (!version.trim()) throw new Error(`The SwiftPM ${variable} compiler identity is unavailable.`);
+		overrides[variable] = {
+			command: await commandPath(command),
+			version
+		};
+	}
+	const checkoutRequired = Object.keys(overrides).length > 0 || selected !== await realpath("/usr/bin/swift") && selected !== compiler || xcrun !== await realpath("/usr/bin/xcrun") || xcodebuild !== await realpath("/usr/bin/xcodebuild");
+	return {
+		...await readSwiftpmArtifactToolchain(context, void 0, cwd),
+		selection: {
+			command: selected,
+			compiler,
+			sdk,
+			xcrun,
+			xcodebuild,
+			overrides,
+			checkoutRequired
+		}
+	};
+}
+async function privateSnapshot(root, query, privateLockfile, toolchain, env, signal) {
+	const repository = resolve(root, ...query.project.split("/").filter(Boolean).map(() => ".."));
+	const declaration = swiftpmArtifactInputs(query.inputs);
+	return (await fingerprintNativeInputs([
+		...declaration.ignored.map((path) => ({
+			name: `ignored/${path}`,
+			path: join(repository, path)
+		})),
+		...declaration.localFiles.map((path, index) => ({
+			name: `local/${index}`,
+			path: resolve(root, path),
+			optional: true
+		})),
+		...privateLockfile ? [{
+			name: "package-resolved",
+			path: join(root, "Package.resolved"),
+			optional: true
+		}] : []
+	], {
+		parameters: {
+			toolchain,
+			environment: Object.fromEntries([.../* @__PURE__ */ new Set([
+				...declaration.environment,
+				"DEVELOPER_DIR",
+				"TOOLCHAINS",
+				"SDKROOT",
+				"SWIFT_EXEC",
+				"MACOSX_DEPLOYMENT_TARGET"
+			])].toSorted().map((name) => [name, env[name] ?? null]))
+		},
+		signal
+	})).hash;
+}
+/** Certifies actual worker inputs, not the client's transfer digest or cache identity. */
+async function swiftpmWorkerArtifactSnapshot(root, query, toolchain, env, signal) {
+	signal?.throwIfAborted();
+	root = await realpath(root);
+	const repository = await realpath(await gitAsync(root, ["rev-parse", "--show-toplevel"], { signal }));
+	const project = relative(repository, await realpath(root)).split(sep).join("/");
+	const visible = await sourceManifest(repository, true, signal);
+	if (query.project !== project || manifestDigest(visible) !== query.sourceDigest) throw new Error("The SwiftPM worker source does not match its completed transfer.");
+	const declaration = swiftpmArtifactInputs(query.inputs);
+	const build = {
+		...query.build,
+		resources: Object.fromEntries(Object.entries(query.build.resources).map(([name, path]) => [name, relative(root, resolve(repository, path))])),
+		assetCatalog: query.build.assetCatalog ? relative(root, resolve(repository, query.build.assetCatalog)) : null
+	};
+	const snapshot = await swiftpmArtifactSnapshot(root, declaration, build, {
+		swift: toolchain.swift,
+		sdk: toolchain.sdk,
+		xcode: toolchain.xcode,
+		arch: toolchain.arch
+	}, env, signal);
+	const sourcePaths = new Set(visible.map((file) => file.path));
+	const privatePaths = /* @__PURE__ */ new Set([...declaration.ignored.map((path) => resolve(repository, path)), ...declaration.localFiles.map((path) => resolve(root, path))]);
+	for (const path of [
+		build.infoPlist,
+		...Object.values(build.resources),
+		build.assetCatalog
+	]) {
+		if (path === null) continue;
+		const absolute = resolve(root, path);
+		const bundled = await fingerprintNativeInputs([{
+			name: "bundle",
+			path: absolute
+		}], {
+			parameters: null,
+			signal
+		});
+		for (const entry of bundled.entries) {
+			if (entry.kind === "directory") continue;
+			const file = join(absolute, entry.path === "bundle" ? "" : entry.path.slice(7));
+			const name = relative(repository, file).split(sep).join("/");
+			if (!entry.kind.startsWith("file:") || !sourcePaths.has(name) && !privatePaths.has(file)) throw new Error("SwiftPM peer caching requires every ignored bundle file in the private input declaration.");
+		}
+	}
+	const privateLockfile = !sourcePaths.has([project, "Package.resolved"].filter(Boolean).join("/"));
+	const privateHash = await privateSnapshot(root, query, privateLockfile, toolchain, env, signal);
+	const hash = createHash("sha256").update(JSON.stringify([
+		"stim-swiftpm-worker-v1",
+		snapshot.hash,
+		query,
+		privateHash
+	])).digest("hex");
+	const identity = {
+		hash,
+		key: `swiftpm-peer-${hash}`
+	};
+	return {
+		identity,
+		receipt: {
+			query: structuredClone(query),
+			identity,
+			privateHash,
+			privateLockfile,
+			checkoutRequired: toolchain.selection.checkoutRequired
+		}
+	};
+}
+/** Revalidates private inputs of a receipt bound to a verified completed source transfer. */
+async function swiftpmArtifactFromReceipt(root, query, receipt, toolchain, env, signal) {
+	signal?.throwIfAborted();
+	if (!isDeepStrictEqual(query, receipt.query) || typeof receipt.checkoutRequired !== "boolean" || receipt.checkoutRequired !== toolchain.selection.checkoutRequired || !/^[a-f0-9]{64}$/.test(receipt.identity.hash) || receipt.identity.key !== `swiftpm-peer-${receipt.identity.hash}`) return null;
+	return await privateSnapshot(root, query, receipt.privateLockfile, toolchain, env, signal) === receipt.privateHash ? receipt.identity : null;
+}
+//#endregion
 //#region src/offload/worker.ts
 function emit(value) {
 	process.stdout.write(`${JSON.stringify(value)}\n`);
@@ -316,42 +484,18 @@ async function materialize(job, src) {
 		removed
 	};
 }
-function lockfileOf(src) {
-	if (existsSync(join(src, "pnpm-lock.yaml"))) return {
-		file: "pnpm-lock.yaml",
-		command: "pnpm",
-		args: (pkg) => [
-			"install",
-			"--frozen-lockfile",
-			...pkg ? ["--filter", `${pkg}...`] : []
-		]
-	};
-	if (existsSync(join(src, "yarn.lock"))) return {
-		file: "yarn.lock",
-		command: "yarn",
-		args: () => ["install", "--frozen-lockfile"]
-	};
-	if (existsSync(join(src, "package-lock.json"))) return {
-		file: "package-lock.json",
-		command: "npm",
-		args: () => ["ci"]
-	};
-	return null;
-}
 /** Installs JavaScript dependencies when the lockfile, or the install command, changed since the last install. */
 async function ensureDependencies(job, src) {
-	const lock = lockfileOf(src);
-	if (!lock) return;
-	const args = lock.args(job.packageName);
-	const lockfile = readFileSync(join(src, lock.file));
-	const digest = createHash("sha256").update(lockfile).update(JSON.stringify(args)).digest("hex");
+	const install = dependencyInstall(src, job.packageName);
+	if (!install) return;
+	const { command, args, digest, lockfile } = install;
 	const marker = join(job.area, "dependencies");
-	const installed = () => writeFileSync(join(job.area, "lockfile"), createHash("sha256").update(lockfile).digest("hex"));
+	const installed = () => writeFileSync(join(job.area, "lockfile"), lockfile);
 	if (existsSync(join(src, job.project, "node_modules")) && existsSync(marker)) {
 		if (readFileSync(marker, "utf8") === digest) return installed();
 	}
-	note("deps", `${lock.command} ${args.join(" ")}`);
-	const child = getExecutor().spawn(lock.command, args, {
+	note("deps", `${command} ${args.join(" ")}`);
+	const child = getExecutor().spawn(command, args, {
 		cwd: src,
 		env: {
 			...process.env,
@@ -374,7 +518,7 @@ async function ensureDependencies(job, src) {
 		child.on("error", reject);
 		child.on("exit", resolve);
 	});
-	if (code !== 0) throw new Error(`${lock.command} ${args.join(" ")} exited with ${code}: ${tail.join(" | ")}`);
+	if (code !== 0) throw new Error(`${command} ${args.join(" ")} exited with ${code}: ${tail.join(" | ")}`);
 	writeFileSync(marker, digest);
 	installed();
 }
@@ -390,7 +534,7 @@ function destination(runtime) {
 			"devices",
 			"available",
 			"-j"
-		], { timeoutMs: 2e4 }) ?? "{}").devices?.[runtime] ?? []).find((each) => each.name.startsWith("iPhone"));
+		], { timeoutMs: 2e4 }) ?? "{}").devices?.[runtime] ?? []).find(availableIphone);
 		return device ? `id=${device.udid}` : null;
 	} catch {
 		return null;
@@ -487,17 +631,7 @@ async function build(job) {
 		compiled = await compileNativeAndroid(job, root, log, time);
 		if (!compiled.ok) return failed(compiled.code, compiled.message);
 		try {
-			const model = JSON.parse(readFileSync(join(workspaceDir(root), "gradle-build", `native-apk-${encodeURIComponent(job.android?.variant ?? "debug")}.json`), "utf8"));
-			const outputs = await nativeGradleOutputs(src, job.native.inputs, model.buildDirectories);
 			if (!await verifyGradleTransfer(src, job.project, job.native.inputs, job.manifest, job.native.sourceDigest)) throw new Error("The native source changed while the worker compiled it.");
-			const directories = [...outputs, ...gradleStateDirectories(job.project).filter((path) => lstatSync(join(src, path), { throwIfNoEntry: false })?.isDirectory())];
-			const receipt = join(job.area, "gradle-outputs.json");
-			const tmp = `${receipt}.${process.pid}.tmp`;
-			writeFileSync(tmp, JSON.stringify({
-				project: job.project,
-				directories
-			}));
-			renameSync(tmp, receipt);
 		} catch (error) {
 			if (compiled.temporary) rmSync(compiled.temporary, {
 				recursive: true,
@@ -606,6 +740,9 @@ async function build(job) {
 			if (mutations.includes("prebuild")) recordPrebuild(realRoot, platform, after.hash);
 		}
 		if (fingerprint !== job.expectedFingerprint) return failed("fingerprint-mismatch", `the checkout there fingerprints ${fingerprint.slice(0, 12)}, here ${job.expectedFingerprint?.slice(0, 12)}`);
+		const tools = job.cacheArtifact ? await reactNativeArtifactToolchain(platform, realRoot) : null;
+		const query = tools ? reactNativeBuildQuery(job, fingerprint, job.project, tools) : null;
+		const receipt = query ? reactNativeArtifactReceipt(query, tools) : null;
 		compiled = platform === "android" ? await compileAndroid(job, realRoot, log, time, androidLayout) : await compileIos(job, realRoot, log, time);
 		if (!compiled.ok) return failed(compiled.code, compiled.message);
 		const builtFingerprint = fingerprint;
@@ -617,6 +754,8 @@ async function build(job) {
 			androidLayout
 		}));
 		if (!settled || settled.moved) return failed("fingerprint-moved", "The inputs changed during the build there.");
+		const after = query && receipt ? reactNativeArtifactReceipt(query, await reactNativeArtifactToolchain(platform, realRoot)) : null;
+		if (receipt && after && isDeepStrictEqual(receipt, after)) compiled.reactNativeArtifact = receipt;
 	}
 	try {
 		const out = join(job.area, "out", job.job);
@@ -645,6 +784,9 @@ async function build(job) {
 			fingerprint,
 			...compiled.androidPackage ? { androidPackage: compiled.androidPackage } : {},
 			...job.native ? { sourceDigest: job.native.sourceDigest } : {},
+			...compiled.cacheArtifact ? { cacheArtifact: compiled.cacheArtifact } : {},
+			...compiled.reactNativeArtifact ? { reactNativeArtifact: compiled.reactNativeArtifact } : {},
+			...compiled.swiftpmArtifact ? { swiftpmArtifact: compiled.swiftpmArtifact } : {},
 			compilationCache: compiled.cache,
 			timings
 		};
@@ -771,6 +913,25 @@ async function compileNativeIos(job, root, log, time) {
 		if (existsSync(logFile)) for (const record of parseNdjsonText(readFileSync(logFile, "utf8"))) log.write(record);
 	}
 }
+async function validateNativeAndroidOutputs(job, root) {
+	if (job.native?.provider !== "gradle") throw new Error("A native Gradle source declaration is required.");
+	try {
+		const src = realpathSync(join(job.area, "src"));
+		const model = JSON.parse(readFileSync(join(workspaceDir(root), "gradle-build", `native-apk-${encodeURIComponent(job.android?.variant ?? "debug")}.json`), "utf8"));
+		const outputs = await nativeGradleOutputs(src, job.native.inputs, model.buildDirectories);
+		if (!await verifyGradleTransfer(src, job.project, job.native.inputs, job.manifest, job.native.sourceDigest)) throw new Error("The native source changed while the worker compiled it.");
+		const directories = [...outputs, ...gradleStateDirectories(job.project).filter((path) => lstatSync(join(src, path), { throwIfNoEntry: false })?.isDirectory())];
+		const receipt = join(job.area, "gradle-outputs.json");
+		const tmp = `${receipt}.${process.pid}.tmp`;
+		writeFileSync(tmp, JSON.stringify({
+			project: job.project,
+			directories
+		}));
+		renameSync(tmp, receipt);
+	} catch (error) {
+		throw Object.assign(new Error(error.message), { code: "source-moved" });
+	}
+}
 async function compileNativeAndroid(job, root, log, time) {
 	const options = job.android;
 	if (!options) return {
@@ -795,6 +956,7 @@ async function compileNativeAndroid(job, root, log, time) {
 	};
 	process.once("SIGTERM", stop);
 	const logFile = join(workspaceLogsDir$1(root), "build-android.ndjson");
+	let cacheArtifact;
 	note("build", `native Gradle ${options.variant ?? "debug"}`);
 	try {
 		rmSync(logFile, { force: true });
@@ -802,16 +964,32 @@ async function compileNativeAndroid(job, root, log, time) {
 			variant: options.variant ?? void 0,
 			abi: options.abi ?? "all",
 			remoteBuild: "local"
-		}, { cacheArtifacts: false })));
-		if (built.cacheKey !== null || !built.cacheSkipped || !built.androidPackage) {
+		}, {
+			cachePolicy: job.native?.provider === "gradle" && job.native.cache ? job.native.cache : {
+				read: false,
+				write: false,
+				remote: false
+			},
+			artifactScope: {
+				key: job.native?.provider === "gradle" ? nativeGradleWorkerScope(job.native.sourceDigest, job.native.inputs) : "null",
+				validate: () => validateNativeAndroidOutputs(job, root),
+				record: (identity, receipt) => {
+					cacheArtifact = {
+						identity,
+						receipt
+					};
+				}
+			}
+		})));
+		if (!built.androidPackage) {
 			rmSync(dirname(built.apkPath), {
 				recursive: true,
 				force: true
 			});
 			return {
 				ok: false,
-				code: "unexpected-cache-identity",
-				message: "The native Gradle worker returned an unsupported artifact identity or package."
+				code: "invalid-package",
+				message: "The native Gradle worker returned no verified APK package."
 			};
 		}
 		return {
@@ -819,12 +997,13 @@ async function compileNativeAndroid(job, root, log, time) {
 			path: built.apkPath,
 			temporary: dirname(built.apkPath),
 			cache: built.ccache,
-			androidPackage: built.androidPackage
+			androidPackage: built.androidPackage,
+			...cacheArtifact && cacheArtifact.identity.key === built.cacheKey ? { cacheArtifact } : {}
 		};
 	} catch (error) {
 		return {
 			ok: false,
-			code: "native-build-failed",
+			code: error instanceof Error && "code" in error && error.code === "source-moved" ? "source-moved" : "native-build-failed",
 			message: error.message
 		};
 	} finally {
@@ -880,6 +1059,26 @@ async function compileMacos(context, job, root, log, time) {
 	};
 	try {
 		const extras = resolveBundleExtras(src, src, options.resources, options.assetCatalog);
+		const query = job.cacheArtifact && options.artifactInputs && job.expectedFingerprint && job.stimBuild ? {
+			project: job.project,
+			sourceDigest: job.expectedFingerprint,
+			stimBuild: job.stimBuild,
+			inputs: options.artifactInputs,
+			build: {
+				product: options.product,
+				infoPlist: options.infoPlist,
+				resources: options.resources ?? {},
+				assetCatalog: options.assetCatalog ?? null
+			}
+		} : null;
+		const snapshot = async () => query ? swiftpmWorkerArtifactSnapshot(root, query, await readSwiftpmWorkerToolchain(context, root), context.env) : null;
+		let before = null;
+		try {
+			before = await snapshot();
+		} catch (error) {
+			context.signal.throwIfAborted();
+			note("build", `SwiftPM artifact inventory unavailable: ${String(error)}`);
+		}
 		return await time("buildMs", async () => {
 			await run([
 				"build",
@@ -904,10 +1103,20 @@ async function compileMacos(context, job, root, log, time) {
 			], true);
 			const bundle = join(job.area, "out", job.job, `${options.product}.app`);
 			await stageBundle(context, root, options.product, options.infoPlist, bin, bundle, options.bundleId, extras);
+			let swiftpmArtifact = null;
+			if (before) try {
+				const after = await snapshot();
+				if (after?.identity.hash === before.identity.hash) swiftpmArtifact = after;
+				else note("build", "SwiftPM inputs changed during the build; not retaining its artifact.");
+			} catch (error) {
+				context.signal.throwIfAborted();
+				note("build", `SwiftPM artifact inventory skipped: ${String(error)}`);
+			}
 			return {
 				ok: true,
 				path: bundle,
-				cache: {}
+				cache: {},
+				...swiftpmArtifact ? { swiftpmArtifact } : {}
 			};
 		});
 	} catch (error) {
@@ -940,7 +1149,7 @@ async function compileIos(job, root, log, time) {
 	}));
 	if (!built.ok) {
 		if (built.compilationCacheCorruption) {
-			const report = clearCorruptCompilationCache(built.compilationCacheCorruption, root);
+			const report = await clearCorruptCompilationCache(built.compilationCacheCorruption, root);
 			return {
 				ok: false,
 				code: report.code,
@@ -1030,10 +1239,12 @@ async function compileAndroid(job, root, log, time, layout) {
 				message: first ?? (built.lastLines.slice(-3).join(" | ") || built.reason)
 			};
 		}
+		const androidPackage = built.androidPackage ?? apkPackage(await dumpApkManifest(built.apkPath));
 		return {
 			ok: true,
 			path: built.apkPath,
-			cache: built.ccache ?? CCACHE_UNAVAILABLE
+			cache: built.ccache ?? CCACHE_UNAVAILABLE,
+			...androidPackage ? { androidPackage } : {}
 		};
 	} finally {
 		process.off("SIGTERM", stop);
@@ -1045,6 +1256,27 @@ async function main() {
 	if (mode === "offer") return emit(workerToolchain(process.argv[3] ?? null));
 	if (mode === "offer-native-xcode") return emit(workerToolchain(null, "xcode"));
 	if (mode === "offer-native-gradle") return emit(workerToolchain(null, "gradle"));
+	if (mode === "native-gradle-artifact") {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(chunk);
+		const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+		if (!/^[a-f0-9]{64}$/.test(input.sourceDigest)) throw new Error("The completed transfer identity is invalid.");
+		gradleOffloadInputs(input.inputs);
+		if (input.android) {
+			const { android, receipt } = input;
+			if (android.variant !== null && android.variant !== receipt.build.variant || (android.abi === "all" ? null : android.abi) !== receipt.abi || android.compilerCache !== receipt.build.compilerCache || android.gradleBuildCache !== receipt.build.gradleBuildCache || android.pch !== receipt.build.pch || receipt.build.cas !== null) throw new Error("The completed Gradle build choices do not match this artifact request.");
+		}
+		const snapshot = await workerOperation(input.root, (context) => nativeGradleArtifactSnapshotFromReceipt(input.root, input.receipt, context.env, context.signal));
+		return emit({ identity: nativeGradleWorkerArtifactIdentity(snapshot.hash, nativeGradleWorkerScope(input.sourceDigest, input.inputs), input.receipt.build.variant ?? "debug", input.receipt.abi) });
+	}
+	if (mode === "swiftpm-artifact") {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(chunk);
+		const input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+		const checkout = existsSync(input.root);
+		if (!checkout && input.receipt.checkoutRequired !== false) return emit({ identity: null });
+		return emit({ identity: await workerOperation(input.root, async (context) => swiftpmArtifactFromReceipt(input.root, input.query, input.receipt, await readSwiftpmWorkerToolchain(context, checkout ? input.root : process.cwd()), context.env)) });
+	}
 	if (mode === "build") {
 		const chunks = [];
 		for await (const chunk of process.stdin) chunks.push(chunk);
@@ -1053,7 +1285,7 @@ async function main() {
 			...await build(JSON.parse(Buffer.concat(chunks).toString("utf8")))
 		});
 	}
-	process.stderr.write("usage: offload-worker offer | offer-native-xcode | offer-native-gradle | build < job.json\n");
+	process.stderr.write("usage: offload-worker offer | offer-native-xcode | offer-native-gradle | native-gradle-artifact | build < job.json\n");
 	process.exitCode = 2;
 }
 main().catch((error) => {