stim 1.20.2 → 1.22.0

package/dist/{native-xcode-ios-Bbf30Gm0.mjs → native-xcode-ios-BYDOHWLN.mjs}

@@ -1,36 +1,66 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as register } from "./cache-manifest-XH-fvDUj.mjs";
-import { Dt as repoRoot, H as remoteIosSetting, Q as settingShapeErrors, W as resolveCacheProviderConfig, ht as gitCommonDir, q as resolveSettings } from "./settings-B717odTD.mjs";
-import { T as filesystemBuildCapability, b as buildCacheKey } from "./device-lease-BX1sJQ2E.mjs";
-import { g as sharedCompilationCache } from "./workspace-state-DJt_MMvf.mjs";
-import { f as NativeXcodeError, h as selectNativeXcodeProject, m as pbxString } from "./project-_phNIJfs.mjs";
-import { It as statsProjectKey } from "./budget-f7516Zk0.mjs";
-import { l as artifactCachePolicy, p as resolveOptimizations } from "./errors-DzkMYh8Q.mjs";
-import { a as nativeTransferRefusal } from "./client-qQAaXSUs.mjs";
-import { i as skippedMissReason, t as explainBuildMiss } from "./miss-reason-mKzZ4VvN.mjs";
-import { C as compilationCacheSettings, D as parseXcodeMajor, E as parseSwiftVersion, f as podsAreStale, g as runPodInstall, h as runCaptured, p as readPodState, r as iosToolchain, x as buildXcode, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DxSsNssu.mjs";
-import { n as planFlagRefusal, t as planCachedBuild } from "./build-plan-B7SZsc2N.mjs";
-import { a as deviceModelRefusal, h as resolveDeviceType, m as resolveConfiguration, v as resolveRuntime, x as simulatorBuildArch, y as resolveSchemeSelection } from "./support-CwjbFs9H.mjs";
-import { t as IosRecipeRefusal } from "./ios-project-K9hY_Jab.mjs";
-import { d as gateProfileForDevice, i as DEFAULT_DEPS, r as iosProcessRuntime } from "./launch-C3qJ6Agb.mjs";
-import { a as nativeXcodeSources, i as nativeXcodePackages, n as nativeXcodeInputSnapshot, t as nativeXcodeHasPackages } from "./native-xcode-inputs-CykopJdM.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { o as sharedCompilationCache } from "./paths-DQtTgsBf.mjs";
+import { G as resolveCacheProviderConfig, Nt as repoRootAsync, U as remoteIosSetting, et as settingShapeErrors } from "./settings-C7O8A6ZI.mjs";
+import { g as selectNativeXcodeProject, h as pbxString, p as NativeXcodeError } from "./project-wM_XFTvE.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { Fn as processContext, Y as statsProjectKey } from "./budget-Cvwn54qV.mjs";
+import { d as runCancellationSignal } from "./native-run-NwUuxbkg.mjs";
+import { n as buildCacheKey, s as filesystemBuildCapability } from "./build-cache-Dv7RN200.mjs";
+import { l as artifactCachePolicy, p as resolveOptimizations } from "./errors-ccaPc4ox.mjs";
+import { a as buildXcode, l as parseSwiftVersion, r as HEARTBEAT_INTERVAL_MS, s as compilationCacheSettings, u as parseXcodeMajor } from "./xcode-BXn9-xYx.mjs";
+import { a as nativeTransferRefusal } from "./client-OyRoEuSr.mjs";
+import { _ as runCaptured, a as iosToolchainAsync, h as readPodState, m as podsAreStale, v as runPodInstall } from "./toolchain-DpJMHq0n.mjs";
+import { a as deviceModelRefusal, h as resolveDeviceType, m as resolveConfiguration, v as resolveRuntime, x as simulatorBuildArch, y as resolveSchemeSelection } from "./support-CNioewsd.mjs";
+import { r as gateProfileForDevice } from "./ios-signing-BtAffm0A.mjs";
+import { l as skippedMissReason, o as explainBuildMiss } from "./prebuild-D4JoEAEs.mjs";
+import { n as planFlagRefusal, t as planCachedBuild } from "./build-plan-DUC8Ka9y.mjs";
+import { t as IosRecipeRefusal } from "./ios-project-CZhKODF3.mjs";
+import { i as DEFAULT_DEPS, r as iosProcessRuntime } from "./launch-BjxemNpK.mjs";
+import { a as nativeXcodeSources, i as nativeXcodePackages, n as nativeXcodeInputSnapshot, t as nativeXcodeHasPackages } from "./native-xcode-inputs-D_VOfFL7.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 //#region src/integrations/native-xcode-ios.ts
-function toolchain(sdk) {
+async function toolchain(sdk, context) {
 	const executor = getExecutor();
+	const env = context?.env ?? process.env;
+	const signal = context?.signal;
+	const childEnv = Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+	const omitEnv = Object.keys(process.env).filter((name) => env[name] === void 0);
+	const probe = async (file, args) => {
+		signal?.throwIfAborted();
+		let cancel;
+		try {
+			return await executor.runFileAsync(file, args, {
+				timeoutMs: 1e4,
+				env: childEnv,
+				omitEnv,
+				cwd: context?.cwd,
+				onSpawn(child) {
+					if (!signal) return;
+					cancel = () => {
+						child.kill("SIGKILL");
+					};
+					signal.addEventListener("abort", cancel, { once: true });
+					if (signal.aborted) cancel();
+				}
+			});
+		} finally {
+			if (cancel) signal?.removeEventListener("abort", cancel);
+			signal?.throwIfAborted();
+		}
+	};
 	const identity = {
-		xcode: executor.runFile("xcodebuild", ["-version"], { timeoutMs: 1e4 }),
-		sdk: executor.runFile("xcodebuild", [
+		xcode: await probe("xcodebuild", ["-version"]),
+		sdk: await probe("xcodebuild", [
 			"-version",
 			"-sdk",
 			sdk
-		], { timeoutMs: 1e4 }),
-		swift: executor.runFile("xcrun", ["swift", "--version"], { timeoutMs: 1e4 }),
-		clang: executor.runFile("xcrun", ["clang", "--version"], { timeoutMs: 1e4 }),
-		developer: executor.runFile("xcode-select", ["-p"], { timeoutMs: 1e4 }),
-		developerOverride: process.env.DEVELOPER_DIR ?? "",
-		toolchains: process.env.TOOLCHAINS ?? ""
+		]),
+		swift: await probe("xcrun", ["swift", "--version"]),
+		clang: await probe("xcrun", ["clang", "--version"]),
+		developer: await probe("xcode-select", ["-p"]),
+		developerOverride: env.DEVELOPER_DIR ?? "",
+		toolchains: env.TOOLCHAINS ?? ""
 	};
 	if (!identity.xcode.trim() || !identity.sdk.trim() || !identity.swift.trim() || !identity.clang.trim() || !identity.developer.trim()) throw new Error("An Xcode toolchain probe returned no identity.");
 	return identity;
@@ -46,14 +76,8 @@ function refusal(error) {
 		remedy: "Check the native Xcode project and its selected toolchain, then retry."
 	};
 }
-function settingsContext(root) {
-	return {
-		projectPath: root,
-		gitCommonDir: gitCommonDir(root),
-		repoRoot: repoRoot(root)
-	};
-}
 function nativeRecipe(root, context) {
+	const env = context.operation?.env ?? process.env;
 	const configuration = context.configuration ?? "Debug";
 	let selected = selectNativeXcodeProject(root, context.buildScheme, configuration);
 	let tools = null;
@@ -76,7 +100,7 @@ function nativeRecipe(root, context) {
 			throw new IosRecipeRefusal(refusal(error));
 		}
 	};
-	const read = () => {
+	const read = async () => {
 		if (!tools) return { cacheIneligible: ineligible ?? "Xcode toolchain identity is unavailable" };
 		reselect();
 		return nativeXcodeInputSnapshot(root, selected, {
@@ -84,17 +108,21 @@ function nativeRecipe(root, context) {
 			architecture: context.target.keyArch,
 			toolchain: tools,
 			optimizations: context.optimizations
-		}, repoRoot(root) ?? root);
+		}, env, await repoRootAsync(root, {
+			env,
+			signal: context.operation?.signal
+		}) ?? root, context.operation?.signal);
 	};
 	return {
 		async identity() {
 			try {
-				tools = toolchain(context.target.sdk);
+				tools = await toolchain(context.target.sdk, context.operation);
 			} catch (error) {
+				context.operation?.signal.throwIfAborted();
 				ineligible = `Xcode toolchain identity is unavailable: ${error.message}`;
 				return { cacheIneligible: ineligible };
 			}
-			const value = read();
+			const value = await read();
 			if ("cacheIneligible" in value) {
 				ineligible = value.cacheIneligible;
 				return value;
@@ -102,7 +130,10 @@ function nativeRecipe(root, context) {
 			snapshot = value;
 			return identity(value);
 		},
-		cache: () => filesystemBuildCapability({ sources: snapshot ? nativeXcodeSources(snapshot) : null }),
+		cache: () => filesystemBuildCapability({
+			context: context.operation,
+			sources: snapshot ? nativeXcodeSources(snapshot) : null
+		}),
 		async prepare(beforePrepare) {
 			const pods = readPodState(root, root);
 			const state = podsAreStale(pods.lockText, pods.manifestText);
@@ -110,6 +141,7 @@ function nativeRecipe(root, context) {
 				beforePrepare();
 				context.step("pods");
 				const result = await runPodInstall(root, context.logWriter(), {
+					onHeartbeat: context.note,
 					directory: root,
 					estimateMs: context.estimates().podsMs
 				});
@@ -139,7 +171,7 @@ function nativeRecipe(root, context) {
 					],
 					cwd: root,
 					env: {
-						...process.env,
+						...env,
 						NSUnbufferedIO: "YES",
 						FORCE_COLOR: "0"
 					},
@@ -161,7 +193,7 @@ function nativeRecipe(root, context) {
 			}
 		},
 		async reconcile() {
-			const current = snapshot && !mutations.length ? snapshot : read();
+			const current = snapshot && !mutations.length ? snapshot : await read();
 			if ("cacheIneligible" in current) {
 				ineligible = current.cacheIneligible;
 				snapshot = null;
@@ -175,10 +207,11 @@ function nativeRecipe(root, context) {
 		async validate() {
 			if (!snapshot) return null;
 			try {
-				tools = toolchain(context.target.sdk);
-				const after = read();
+				tools = await toolchain(context.target.sdk, context.operation);
+				const after = await read();
 				return !("cacheIneligible" in after) && after.hash === snapshot.hash ? identity(snapshot) : null;
 			} catch {
+				context.operation?.signal.throwIfAborted();
 				return null;
 			}
 		},
@@ -191,10 +224,12 @@ function nativeRecipe(root, context) {
 		},
 		async materialize(path) {
 			if (context.device) {
-				const gate = gateProfileForDevice({
+				const gate = await gateProfileForDevice({
 					appPath: path,
 					udid: context.device.udid,
-					configuration
+					configuration,
+					env: context.operation?.env,
+					signal: runCancellationSignal(context.operation) ?? context.operation?.signal
 				});
 				if (!gate.ok) throw new IosRecipeRefusal({
 					code: gate.code,
@@ -205,6 +240,7 @@ function nativeRecipe(root, context) {
 			return path;
 		},
 		compile: () => buildXcode({
+			context: context.operation,
 			root,
 			project: selected.container,
 			scheme: selected.scheme,
@@ -219,6 +255,7 @@ function nativeRecipe(root, context) {
 			arch: context.target.arch,
 			logWriter: context.logWriter(),
 			estimateMs: context.estimates().coldBuildMs,
+			onHeartbeat: context.note,
 			extraArgs: nativeXcodeHasPackages(selected) ? [
 				"-clonedSourcePackagesDirPath",
 				nativeXcodePackages(root),
@@ -232,7 +269,7 @@ function nativeRecipe(root, context) {
 					casPath,
 					xcodeMajor: parseXcodeMajor(tools?.xcode),
 					swiftVersion: parseSwiftVersion(tools?.swift),
-					swiftCacheCompatible: (!process.env.SWIFT_ENABLE_EXPLICIT_MODULES || process.env.SWIFT_ENABLE_EXPLICIT_MODULES === "YES") && !selected.projects.some((project) => [...project.objects.values()].some((entry) => {
+					swiftCacheCompatible: (!env.SWIFT_ENABLE_EXPLICIT_MODULES || env.SWIFT_ENABLE_EXPLICIT_MODULES === "YES") && !selected.projects.some((project) => [...project.objects.values()].some((entry) => {
 						if (entry.isa !== "XCBuildConfiguration" || pbxString(entry.name) !== configuration) return false;
 						const targetSettings = entry.buildSettings;
 						const explicitModules = pbxString(targetSettings?.SWIFT_ENABLE_EXPLICIT_MODULES);
@@ -242,6 +279,7 @@ function nativeRecipe(root, context) {
 				});
 				if (settings.length && context.optimizations.compilationCache) register({
 					dir: casPath,
+					registeredBy: context.operation?.cwd ?? root,
 					name: "Xcode compilation cache",
 					prune: "atomic",
 					note: "shared Xcode compilation cache"
@@ -268,20 +306,23 @@ function nativeRecipe(root, context) {
 			};
 		},
 		untrackedLine: () => null,
-		legacyCache: null,
+		expoCache: null,
 		offload: {
-			context: () => {
+			context: async () => {
 				const runtime = context.target.sdk === "iphonesimulator" ? context.target.offloadRuntime() : null;
 				return {
 					runtime,
-					unsupported: context.target.offloadRefusal ?? (context.device ? "Physical native Xcode builds build here" : !context.cache.write ? "the build cache is off" : !runtime ? "no simulator runtime is available for worker selection" : !snapshot ? "the native inputs have no verified identity" : nativeTransferRefusal(repoRoot(root) ?? root, snapshot))
+					unsupported: context.target.offloadRefusal ?? (context.device ? "Physical native Xcode builds build here" : !context.cache.write ? "the build cache is off" : !runtime ? "no simulator runtime is available for worker selection" : !snapshot ? "the native inputs have no verified identity" : await nativeTransferRefusal(await repoRootAsync(root, {
+						env,
+						signal: context.operation?.signal
+					}) ?? root, snapshot, runCancellationSignal(context.operation) ?? context.operation?.signal))
 				};
 			},
-			target: (runtime) => ({
+			target: async (runtime) => ({
 				platform: "ios",
 				native: "xcode",
 				local: {
-					...iosToolchain(root, "xcode"),
+					...await iosToolchainAsync(root, "xcode"),
 					...context.target.hostedArchitecture ? { arch: context.target.hostedArchitecture === "x86_64" ? "x64" : "arm64" } : {}
 				},
 				runtime,
@@ -305,22 +346,21 @@ function nativeRecipe(root, context) {
 				};
 			},
 			unchanged: async () => {
-				const current = read();
+				const current = await read();
 				return snapshot !== null && !("cacheIneligible" in current) && current.hash === snapshot.hash;
 			}
 		}
 	};
 }
-async function planNativeXcode(root, options) {
+async function planNativeXcode(root, options, resolved, operation = processContext(root)) {
 	if (options.easProfile !== void 0) return { refusal: planFlagRefusal("--eas-profile") };
 	try {
-		const context = settingsContext(root);
-		const settings = resolveSettings(context);
+		const { context, settings } = resolved;
 		const errors = settingShapeErrors(settings);
 		if (errors.length) throw new NativeXcodeError(errors.join("; "), "Correct the project settings and retry.");
 		if (remoteIosSetting(settings)) throw new NativeXcodeError("Native Xcode planning does not resolve hosted placement.", "Unset ios.remote to plan a local build, or run stim ios without --plan.");
 		const layers = DEFAULT_DEPS.settingsLayers(context);
-		const modelRefusal = deviceModelRefusal({
+		const modelRefusal = await deviceModelRefusal({
 			slot: options.slot ?? "default",
 			deviceTypeFlag: options.deviceType,
 			runtimeFlag: options.runtime,
@@ -330,7 +370,8 @@ async function planNativeXcode(root, options) {
 			runtimeOrigin: DEFAULT_DEPS.settingOriginScope(layers, "ios.runtime"),
 			physical: false,
 			remoteBackend: null,
-			listRuntimes: DEFAULT_DEPS.listIosRuntimes
+			listRuntimes: DEFAULT_DEPS.listIosRuntimes,
+			signal: operation?.signal
 		});
 		if (modelRefusal) return { refusal: modelRefusal };
 		const configuration = resolveConfiguration(options.configuration, settings) ?? "Debug";
@@ -342,12 +383,12 @@ async function planNativeXcode(root, options) {
 			hostArch: process.arch === "arm64" ? "arm64" : "x86_64",
 			configuration
 		});
-		const snapshot = nativeXcodeInputSnapshot(root, selection, {
+		const snapshot = await nativeXcodeInputSnapshot(root, selection, {
 			sdk: "iphonesimulator",
 			architecture,
-			toolchain: toolchain("iphonesimulator"),
+			toolchain: await toolchain("iphonesimulator", operation),
 			optimizations: optimizations.ios
-		}, context.repoRoot ?? root);
+		}, operation?.env ?? process.env, context.repoRoot ?? root, operation?.signal);
 		if ("cacheIneligible" in snapshot) throw new NativeXcodeError(`No reusable native artifact can be predicted: ${snapshot.cacheIneligible}.`, "Run stim ios without --plan; it can prepare dependencies and build locally without artifact caching.");
 		const key = buildCacheKey("ios", snapshot.hash, {
 			configuration,
@@ -373,10 +414,13 @@ async function planNativeXcode(root, options) {
 			expoRemote: null
 		}, {
 			...DEFAULT_DEPS,
+			operation,
 			planPrebuild: () => "none",
-			note: (line) => console.error(line)
+			note: (line) => operation.output("stderr", `${line}\n`)
 		});
 	} catch (error) {
+		if (error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return { refusal: refusal(error) };
 	}
 }
@@ -390,7 +434,7 @@ function nativeXcodeIosProject(root) {
 		],
 		eas: false,
 		runtimeKind: () => "process",
-		plan: (options) => planNativeXcode(root, options),
+		plan: (options, resolved, operation) => planNativeXcode(root, options, resolved, operation),
 		bundleId: () => null,
 		schemeProblem(scheme, configuration) {
 			try {

package/dist/{ndjson-GOnbyvso.mjs → ndjson-CgE_o3Dl.mjs}

@@ -1,7 +1,7 @@
+import { ensurePrivateDir, rotateLog } from "@stim-cli/core";
+import { LEVELS as LEVELS$1, SOURCES as SOURCES$1, levelRank, parseNdjsonLine, parseNdjsonText, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
 import { dirname } from "path";
-import { LEVELS, SOURCES, levelRank, parseNdjsonLine, parseNdjsonText, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
 import { closeSync, openSync, writeSync } from "fs";
-import { ensurePrivateDir, rotateLog } from "@stim-cli/core";
 //#region src/ndjson.ts
 const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
@@ -115,4 +115,4 @@ function stamp(record) {
 	};
 }
 //#endregion
-export { parseNdjsonLine as a, levelRank as i, SOURCES as n, parseNdjsonText as o, createNdjsonWriter as r, readNdjsonGenerations$1 as s, LEVELS as t };
+export { parseNdjsonLine as a, levelRank as i, SOURCES$1 as n, parseNdjsonText as o, createNdjsonWriter as r, readNdjsonGenerations$1 as s, LEVELS$1 as t };

package/dist/offload-worker.d.mts

@@ -1,49 +1,55 @@
-import { n as CcacheActivity, r as CompilationCacheActivity } from "./build-facts-DcLv2HSd.mjs";
-import "./settings-vk3mJGSm.mjs";
-import "./ndjson-Du3j0AQ9.mjs";
-import "@stim-cli/core/state";
-import { readFileSync } from "fs";
-import "@expo/fingerprint";
-import { BuildStartParams } from "@stim-cli/core/protocol";
-//#region src/optimizations.d.ts
-interface Optimizations {
-  buildCache: boolean;
-  remoteBuildCache: boolean;
-  releaseBundleSwap: boolean;
-  metroSharedCache: boolean;
-  metroWarmup: boolean;
-  ios: {
-    compilationCache: boolean;
-    swiftCompilationCache: boolean | null;
-    prefixMapping: boolean;
+import { c as IosToolchain, g as CompilationCacheActivity, h as CcacheActivity, i as AndroidBuildOptions, l as WorkerToolchain, p as Optimizations, r as SwiftpmArtifactToolchain, t as NativeGradleArtifactReceipt } from "./android-project-DVWyCbWU.mjs";
+import { StimContext } from "@stim-cli/core";
+import { BuildReactNativeArtifactQuery, BuildStartParams, BuildSwiftpmArtifactQuery } from "@stim-cli/core/protocol";
+//#region src/offload/react-native-artifact.d.ts
+type ArtifactTools = (IosToolchain & {
+  os: string;
+}) | Pick<WorkerToolchain, "stimBuild" | "os" | "arch" | "jdk" | "androidSdk">;
+interface ArtifactReceipt {
+  identity: {
+    hash: string;
+    key: string;
   };
-  android: {
-    compilerCache: "ccache" | "cas" | "none";
-    casToolchain: string | null;
-    compilerCacheFallback: CompilerCacheFallback | null;
-    pch: "auto" | "on" | "off";
-    gradleBuildCache: boolean;
-    targetAbiOnly: boolean;
+  receipt: {
+    query: BuildReactNativeArtifactQuery;
+    toolchain: ArtifactTools;
   };
 }
-interface CompilerCacheFallback {
-  key: string;
-  reason: string;
-  fromEnvironment: boolean;
-  manifest: string | null;
-}
+declare function reactNativeArtifactReceipt(query: BuildReactNativeArtifactQuery, toolchain: ArtifactTools | null): ArtifactReceipt | null;
 //#endregion
-//#region src/offload/client.d.ts
-/** The Gradle choices that shape the APK, so the machine builds what this Mac's cache key describes. */
-interface AndroidBuildOptions {
-  variant: string | null;
-  abi: string | null;
-  gradleBuildCache: boolean;
-  pch: "auto" | "on" | "off";
-  compilerCache: "ccache" | "none";
-  gradleRoot?: string | null;
-  module?: string | null;
+//#region src/offload/swiftpm-artifact.d.ts
+interface SwiftpmWorkerToolchain extends SwiftpmArtifactToolchain {
+  selection: {
+    command: string;
+    compiler: string;
+    sdk: string;
+    xcrun: string;
+    xcodebuild: string;
+    overrides: Record<string, {
+      command: string;
+      version: string;
+    }>;
+    checkoutRequired: boolean;
+  };
+}
+interface SwiftpmArtifactReceipt {
+  query: BuildSwiftpmArtifactQuery;
+  identity: {
+    hash: string;
+    key: string;
+  };
+  privateHash: string;
+  privateLockfile: boolean;
+  checkoutRequired: boolean;
 }
+/** Certifies actual worker inputs, not the client's transfer digest or cache identity. */
+declare function swiftpmWorkerArtifactSnapshot(root: string, query: BuildSwiftpmArtifactQuery, toolchain: SwiftpmWorkerToolchain, env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<{
+  identity: {
+    hash: string;
+    key: string;
+  };
+  receipt: SwiftpmArtifactReceipt;
+}>;
 //#endregion
 //#region src/offload/worker.d.ts
 /** One entry of the source transfer: a visible file of the checkout, or a native build's file or directory input. */
@@ -66,6 +72,7 @@ interface WorkerJob {
     bundleId: string;
     resources?: Record<string, string>;
     assetCatalog?: string | null;
+    artifactInputs?: BuildSwiftpmArtifactQuery["inputs"];
   } | null;
   swiftpmCache: string;
   project: string;
@@ -77,6 +84,8 @@ interface WorkerJob {
   runtime: string | null;
   android: AndroidBuildOptions | null;
   expectedFingerprint: string | null;
+  cacheArtifact?: boolean;
+  stimBuild?: string;
   native?: BuildStartParams["native"];
   optimizations: Optimizations["ios"] | null;
   /** How long the client's Gradle daemon stays warm after an Android build; 0 or absent stops it when the build ends. */
@@ -102,6 +111,15 @@ type WorkerResult = {
   fingerprint: string | null;
   androidPackage?: string;
   sourceDigest?: string;
+  cacheArtifact?: {
+    identity: {
+      hash: string;
+      key: string;
+    };
+    receipt: NativeGradleArtifactReceipt;
+  };
+  reactNativeArtifact?: NonNullable<ReturnType<typeof reactNativeArtifactReceipt>>;
+  swiftpmArtifact?: Awaited<ReturnType<typeof swiftpmWorkerArtifactSnapshot>>;
   compilationCache: CompilationCacheActivity | CcacheActivity | Record<string, never>;
   timings: WorkerTimings;
 } | {