stim 1.20.2 → 1.22.0

package/dist/result-D2Ykz_iD.mjs

@@ -0,0 +1,435 @@
+import { l as workspaceAgentDeviceDir } from "./paths-DQtTgsBf.mjs";
+import { H as deviceSlotPlatforms, p as getProject } from "./config-DlrsduwG.mjs";
+import { i as formatDuration, l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { $ as settingOriginScope, F as parseIosRemote, G as resolveCacheProviderConfig, V as remoteAndroidSetting, W as resolveAndroidLayout, Z as settingFile, a as SETTING_SHAPE_REMEDY, d as androidLayoutSetting, et as settingShapeErrors, f as androidLayoutSettingError, it as unknownSettingKeys, nt as settingsLayers, p as cacheProviderSettingError, s as androidAvdConfigSettingError, u as androidDataPartitionSizeGbSettingError } from "./settings-C7O8A6ZI.mjs";
+import { v as detectIsExpo } from "./project-wM_XFTvE.mjs";
+import { B as recordFinishedBuild, Hn as isEasAuthFailureText, Rn as UPLOAD_TIMEOUT_MS, Vn as easAuthNote, zn as cacheLevel } from "./budget-Cvwn54qV.mjs";
+import { B as ownedAvdDeviceProfile, I as listInstalledSystemImages, K as ownedAvdSystemImage, N as listAvdDeviceProfilesAsync, Q as profileNeedsFoldFeature, X as pickDefaultSystemImage, _t as parkedMaxSetting, rt as systemImageSupportsFold, t as DEFAULT_AVD_DEVICE_PROFILE } from "./android-C7sVmyI9.mjs";
+import { a as workspaceLinkLine } from "./stim-desktop-D5OGpYZM.mjs";
+import { d as optimizationBuildProfile, l as artifactCachePolicy, p as resolveOptimizations, u as compilerCacheFallbackMessage } from "./errors-ccaPc4ox.mjs";
+import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine } from "./ccache-Btwc36-I.mjs";
+import { c as readProductFlavors, s as productFlavorRefusal } from "./react-native-build-Dvd8hC21.mjs";
+import { l as parseDeviceWait } from "./device-lease-run-xJPQ_QQG.mjs";
+import { t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-DK5_EwRS.mjs";
+import { n as resolveAndroidCas, r as resolveAndroidCompilerCache } from "./android-cas-ngferVq2.mjs";
+import { r as isPhysicalDeviceRequest } from "./native-runtime-B7KIafpM.mjs";
+import { C as remoteAvdFlagRefusal, D as systemImageRefusal, E as resolveVariant, T as resolveSystemImage, a as PLATFORM, m as deviceProfileRefusal, v as foldableImageRefusal, w as resolveDeviceProfile, y as isReleaseVariant } from "./support-yUiOjnVY.mjs";
+import { buildDiagnostics } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/android/plan.ts
+function slotOwnedAvd(projectPath, slot) {
+	const android = deviceSlotPlatforms(getProject(projectPath), slot)?.android;
+	if (!android?.owned || !android.avdName || android.setupIncomplete) return null;
+	const systemImage = ownedAvdSystemImage(android.avdName);
+	return systemImage ? {
+		avdName: android.avdName,
+		systemImage,
+		deviceProfile: ownedAvdDeviceProfile(android.avdName)
+	} : null;
+}
+function fail(code, message, remedy, { lines = [] } = {}) {
+	return {
+		ok: false,
+		code,
+		message,
+		remedy,
+		lines
+	};
+}
+function androidLayoutError(settings, root, bound, isExpo) {
+	const error = androidLayoutSettingError(settings, root, bound);
+	if (error || !androidLayoutSetting(settings, root, bound).custom || !isExpo()) return error;
+	return "android.gradleRoot and android.module apply to bare React Native apps only: expo prebuild generates and builds android/. Remove them for this Expo app.";
+}
+function androidCompilerCache({ root, optimizations, env, settingsContext, layout }) {
+	const { cas, optimizations: resolved } = resolveAndroidCompilerCache({
+		optimizations,
+		env,
+		use: (manifest) => resolveAndroidCas(root, {
+			...env,
+			STIM_ANDROID_CAS_TOOLCHAIN: manifest
+		}, layout)
+	});
+	const fallback = resolved.android.compilerCacheFallback;
+	if (!fallback) return {
+		cas,
+		optimizations: resolved,
+		warning: null
+	};
+	return {
+		cas,
+		optimizations: resolved,
+		warning: `Warning: ${compilerCacheFallbackMessage({
+			fallback,
+			compilerCache: resolved.android.compilerCache === "none" ? "none" : "ccache",
+			file: settingFile(settingsContext, fallback.key)
+		})}`
+	};
+}
+function resolveAndroidBuildPlan({ settings, settingsContext, env, easProfile, variant: variantFlag, buildCache: requestedBuildCache }, { warn, runtimeKind, resolveCompilerCache = androidCompilerCache, resolveCacheProvider = resolveCacheProviderConfig, variantProblem, detectExpo = () => detectIsExpo(settingsContext.projectPath) }) {
+	const root = settingsContext.projectPath;
+	const [shapeError, ...moreShapeErrors] = settingShapeErrors(settings);
+	if (shapeError) return fail("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY, { lines: moreShapeErrors });
+	const bound = settingsContext.repoRoot ?? root;
+	const layoutError = androidLayoutError(settings, root, bound, detectExpo);
+	if (layoutError) return fail("STIM_BAD_ARG", layoutError, SETTING_SHAPE_REMEDY);
+	const layout = resolveAndroidLayout(settings, root, bound);
+	for (const key of unknownSettingKeys(settings)) warn("setting", `Warning: setting "${key}" is not read by Stim and will be ignored.`);
+	let optimizations;
+	try {
+		optimizations = resolveOptimizations(settings, env);
+	} catch (error) {
+		return fail("STIM_BAD_ARG", `Could not configure Android build: ${error.message}`, SETTING_SHAPE_REMEDY);
+	}
+	const compilerCache = resolveCompilerCache({
+		root,
+		optimizations,
+		settingsContext,
+		layout,
+		env
+	});
+	const cas = compilerCache.cas;
+	optimizations = compilerCache.optimizations;
+	if (compilerCache.warning) warn("cache", compilerCache.warning);
+	const buildProfile = optimizationBuildProfile("android", optimizations);
+	const cacheProviderConfig = resolveCacheProvider(settingsContext);
+	const cacheProviderError = cacheProviderSettingError(settings);
+	if (cacheProviderError) warn("cache", `${cacheProviderError} Using the local cache.`);
+	const variant = easProfile !== void 0 ? "debug" : resolveVariant(variantFlag, settings);
+	const flavorRefusal = variantProblem(variant);
+	if (flavorRefusal) return fail(flavorRefusal.code, flavorRefusal.reason, flavorRefusal.remedy);
+	const release = isReleaseVariant(variant);
+	return {
+		ok: true,
+		plan: {
+			build: {
+				variant,
+				release,
+				profile: buildProfile,
+				cas,
+				cache: artifactCachePolicy(optimizations, requestedBuildCache, runtimeKind({ release }) === "embedded-js"),
+				compilerCache: optimizations.android.compilerCache,
+				gradleBuildCache: optimizations.android.gradleBuildCache,
+				pch: optimizations.android.pch,
+				targetAbiOnly: optimizations.android.targetAbiOnly
+			},
+			metroWarmup: optimizations.metroWarmup,
+			cacheProviderConfig
+		}
+	};
+}
+async function resolveAndroidRunPlan({ settings, settingsContext, env, slot, signal, easProfile, variant: variantFlag, systemImage: systemImageFlag, deviceProfile: deviceProfileFlag, device: deviceFlag, wait: waitFlag, waitConflict, remote: commandRemoteBackend, buildCache: requestedBuildCache }, { warn, runtimeKind, resolveCompilerCache = androidCompilerCache, resolveCacheProvider = resolveCacheProviderConfig, validateAvdConfig = androidAvdConfigSettingError, readFlavors = readProductFlavors, variantProblem = (variant) => productFlavorRefusal({
+	flavors: readFlavors(resolveAndroidLayout(settings, settingsContext.projectPath, settingsContext.repoRoot ?? settingsContext.projectPath)),
+	variant
+}), detectExpo = () => detectIsExpo(settingsContext.projectPath), listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfilesAsync, parkedLimit = parkedMaxSetting, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd }) {
+	const root = settingsContext.projectPath;
+	const [shapeError, ...moreShapeErrors] = [parkedLimit("android").error, ...settingShapeErrors(settings)].filter((error) => Boolean(error));
+	if (shapeError) return fail("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY, { lines: moreShapeErrors });
+	const plannedBuild = resolveAndroidBuildPlan({
+		settings,
+		settingsContext,
+		env,
+		easProfile,
+		variant: variantFlag,
+		buildCache: requestedBuildCache
+	}, {
+		warn,
+		runtimeKind,
+		resolveCompilerCache,
+		resolveCacheProvider,
+		variantProblem,
+		detectExpo
+	});
+	if (!plannedBuild.ok) return plannedBuild;
+	const dataPartitionSizeError = androidDataPartitionSizeGbSettingError(settings);
+	if (dataPartitionSizeError) return fail("STIM_BAD_ARG", dataPartitionSizeError, "Set android.dataPartitionSizeGb to a whole number of GiB from 6 through 16384.");
+	const avdConfigError = validateAvdConfig(settings, root);
+	if (avdConfigError) return fail("STIM_BAD_ARG", avdConfigError, "Use only documented android.avdConfig keys, or an android.avdConfigFile fragment contained by the app directory.");
+	const systemImage = resolveSystemImage(systemImageFlag, settings);
+	const deviceProfile = resolveDeviceProfile(deviceProfileFlag, settings);
+	const isExpo = detectExpo();
+	const physical = isPhysicalDeviceRequest(deviceFlag);
+	if (physical && deviceFlag === "") return fail("STIM_BAD_ARG", "--device was given an empty serial.", "Pass `--device` on its own to take the first connected device this workspace can lease, or `--device <serial>` to name one.");
+	if (physical && commandRemoteBackend !== null && parseIosRemote(commandRemoteBackend)) return fail("STIM_BAD_ARG", `--device installs on a device connected to this machine, and --remote ${commandRemoteBackend} chooses where an emulator runs.`, "Pass only one of --device and --remote, or --remote local with --device.");
+	const noWait = waitFlag === false;
+	if (waitConflict) return fail("STIM_BAD_ARG", "--wait and --no-wait ask for opposite things.", "Pass only one of `--wait <seconds>` and `--no-wait`.");
+	const waitParsed = parseDeviceWait(noWait ? void 0 : waitFlag);
+	if ("error" in waitParsed) return fail("STIM_BAD_ARG", waitParsed.error, "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a busy lease or device slot at once.");
+	const waitSeconds = waitParsed.seconds;
+	const remoteTarget = commandRemoteBackend !== null ? parseIosRemote(commandRemoteBackend) : physical ? null : remoteAndroidSetting(settings);
+	const machine = remoteTarget?.kind === "machine" ? remoteTarget.machine : null;
+	const remoteBackend = !physical && remoteTarget?.kind === "backend" ? remoteTarget.backend : null;
+	if (!machine) {
+		const refusal = await androidDeviceSelectorRefusal({
+			settingsContext,
+			signal,
+			slot,
+			systemImageFlag,
+			deviceProfileFlag,
+			systemImage,
+			deviceProfile,
+			physical,
+			remoteBackend
+		}, {
+			listSystemImages,
+			listDeviceProfiles,
+			supportsFold,
+			ownedAvd
+		});
+		if (refusal) return refusal;
+	}
+	const target = physical ? {
+		kind: "physical",
+		serial: typeof deviceFlag === "string" ? deviceFlag : null,
+		lease: {
+			waitSeconds,
+			noWait
+		}
+	} : machine ? {
+		kind: "hosted",
+		machine,
+		systemImage,
+		deviceProfile
+	} : remoteBackend ? {
+		kind: "remote",
+		backend: remoteBackend,
+		systemImage,
+		deviceProfile
+	} : {
+		kind: "emulator",
+		systemImage,
+		deviceProfile
+	};
+	return {
+		ok: true,
+		plan: {
+			...plannedBuild.plan,
+			target,
+			deviceSlotWaitMs: noWait ? 0 : waitFlag === void 0 && !physical ? DEFAULT_DEVICE_SLOT_WAIT_MS : waitSeconds * 1e3,
+			isExpo
+		}
+	};
+}
+async function androidDeviceSelectorRefusal({ signal, settingsContext, slot, systemImageFlag, deviceProfileFlag, systemImage, deviceProfile, physical, remoteBackend }, { listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfilesAsync, supportsFold = systemImageSupportsFold, ownedAvd = slotOwnedAvd } = {}) {
+	const root = settingsContext.projectPath;
+	const settingsLayersForOrigin = settingsLayers(settingsContext);
+	const imageRefusal = systemImageRefusal({
+		slot,
+		flag: systemImageFlag,
+		resolved: systemImage,
+		origin: settingOriginScope(settingsLayersForOrigin, "android.systemImage"),
+		physical,
+		remoteBackend,
+		listImages: listSystemImages
+	});
+	if (imageRefusal) return fail(imageRefusal.code, imageRefusal.message, imageRefusal.remedy);
+	const profileRefusal = await deviceProfileRefusal({
+		flag: deviceProfileFlag,
+		resolved: deviceProfile,
+		origin: settingOriginScope(settingsLayersForOrigin, "android.deviceProfile"),
+		physical,
+		remoteBackend,
+		listProfiles: listDeviceProfiles,
+		signal
+	});
+	if (profileRefusal) return fail(profileRefusal.code, profileRefusal.message, profileRefusal.remedy);
+	const avdFlagRefusal = remoteAvdFlagRefusal({
+		systemImageFlag,
+		deviceProfileFlag,
+		remoteBackend
+	});
+	if (avdFlagRefusal) return fail(avdFlagRefusal.code, avdFlagRefusal.message, avdFlagRefusal.remedy);
+	if (!physical && !remoteBackend) {
+		const flagImage = typeof systemImageFlag === "string" && systemImageFlag.trim() ? systemImageFlag.trim() : null;
+		const existing = ownedAvd(root, slot);
+		const profile = deviceProfile ?? existing?.deviceProfile ?? DEFAULT_AVD_DEVICE_PROFILE;
+		const image = () => flagImage ?? existing?.systemImage ?? systemImage ?? pickDefaultSystemImage(listSystemImages())?.pkg ?? null;
+		const checked = profileNeedsFoldFeature(profile) ? image() : null;
+		const foldRefusal = checked !== null && foldableImageRefusal({
+			profile,
+			image: checked,
+			avdName: existing && existing.systemImage === checked && existing.deviceProfile === profile ? existing.avdName : null,
+			images: listSystemImages,
+			supportsFold
+		});
+		if (foldRefusal) return fail(foldRefusal.code, foldRefusal.message, foldRefusal.remedy);
+	}
+	return null;
+}
+//#endregion
+//#region src/commands/android/result.ts
+function androidFacts({ root, slot, serial, avdName = null, deviceName = null, systemImage = null, deviceProfile = null, fingerprint, cacheKey = null, variant = null, metroPort = null, cacheHit, cacheSkipped = false, waitedForBuild = null, appPath, bundleId, installSkipped = false, launched, ccache = CCACHE_UNAVAILABLE, logs, debugHttpHost = null, debugHttpHostNote = null, devClientUrl = null, durationMs, lease, devServer = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null, host }) {
+	return {
+		platform: PLATFORM,
+		...host ? { host } : {},
+		...slot && slot !== "default" ? { slot } : {},
+		serial: serial ?? null,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		systemImage: systemImage ?? null,
+		deviceProfile: deviceProfile ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		variant: variant ?? null,
+		metroPort: metroPort ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		buildMachine,
+		...builtOn ? { builtOn } : {},
+		...offloadedTo ? { offloadedTo } : {},
+		...offloadFallback ? { offloadFallback } : {},
+		waitedForBuild: waitedForBuild ? {
+			pid: waitedForBuild.pid ?? null,
+			ms: waitedForBuild.ms ?? 0
+		} : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		installSkipped: Boolean(installSkipped),
+		launched: launched === "unverified" || launched === "bundling" ? launched : Boolean(launched),
+		ccache,
+		debugHttpHost: debugHttpHost ?? null,
+		debugHttpHostNote: debugHttpHostNote ?? null,
+		devClientUrl: devClientUrl ?? null,
+		logs: logs ?? null,
+		...root && !host ? { agentDevice: { stateDir: workspaceAgentDeviceDir(root) } } : {},
+		durationMs: typeof durationMs === "number" && Number.isFinite(durationMs) ? durationMs : null,
+		...lease === void 0 ? {} : { lease },
+		...devServer ? { devServer } : {}
+	};
+}
+function lastBuildRecord({ devicePlacement, fingerprint, cacheKey, cacheHit, cacheSkipped = false, durationMs, appPath, bundleId, startedAt, status, errorCode = null, avdName = null, deviceName = null, missReason = null, diagnostics = null, configuration = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null }) {
+	const record = {
+		platform: PLATFORM,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		durationMs: Number.isFinite(durationMs) ? durationMs : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		startedAt,
+		status,
+		configuration: configuration ?? null
+	};
+	if (errorCode) record.errorCode = errorCode;
+	if (devicePlacement) record.devicePlacement = devicePlacement;
+	record.buildMachine = buildMachine;
+	if (builtOn) record.builtOn = builtOn;
+	if (offloadedTo) record.offloadedTo = offloadedTo;
+	if (offloadFallback) record.offloadFallback = offloadFallback;
+	if (missReason && !cacheLevel(cacheHit)) record.missReason = missReason;
+	const recorded = status === "failed" ? buildDiagnostics(diagnostics) : [];
+	if (recorded.length) record.diagnostics = recorded;
+	return record;
+}
+async function finishAndroidUpload(uploadPending, remote, phase) {
+	if (!uploadPending) return false;
+	const upload = await uploadPending;
+	if (upload?.uploaded) phase("cache", `uploaded (${remote?.name})`);
+	else if (upload?.timedOut) {
+		phase("cache", chalk.yellow(`${remote?.name} upload still running after ${formatDuration(UPLOAD_TIMEOUT_MS)}; not waiting`));
+		return true;
+	} else if (upload?.failed) {
+		const authNote = remote?.name === "eas" && isEasAuthFailureText(upload.failed) ? easAuthNote({
+			code: "logged-out",
+			reason: upload.failed,
+			phase: "upload"
+		}) : null;
+		phase("cache", chalk.yellow(authNote || `${remote?.name} upload failed: ${upload.failed}`));
+	}
+	return false;
+}
+function reportAndroidResult({ host, root, slot, json, useBuildCache, variant, release, runtimeKind = release ? "embedded-js" : "metro", metroCheck, metroPort, logsDir, serial, apkPath, androidPackage, installSkipped, record, waitedForBuild, remote, providerName, launchState, launchWarning, launched, ccache, durationMs, writer, emit, out, lease, recordRun, reclaimed = [], devServer = null, links }) {
+	const offloadedTo = record.offloadedTo ?? null;
+	recordRun({
+		failed: false,
+		cacheHit: cacheLevel(record.cacheHit),
+		waited: waitedForBuild,
+		durationMs,
+		offloadedTo
+	});
+	const facts = androidFacts({
+		host,
+		root,
+		slot,
+		serial,
+		avdName: record.avdName,
+		deviceName: record.deviceName,
+		systemImage: record.systemImage,
+		deviceProfile: record.deviceProfile,
+		debugHttpHost: launched.debugHttpHost ?? null,
+		debugHttpHostNote: launched.debugHttpHostNote ?? null,
+		devClientUrl: launched.devClientUrl ?? null,
+		fingerprint: record.fingerprint,
+		cacheKey: record.cacheKey,
+		variant,
+		metroPort,
+		cacheHit: record.cacheHit,
+		cacheSkipped: record.cacheSkipped || !useBuildCache,
+		waitedForBuild,
+		appPath: apkPath,
+		bundleId: androidPackage,
+		installSkipped,
+		launched: launchState,
+		ccache,
+		logs: logsDir,
+		durationMs,
+		lease,
+		devServer,
+		buildMachine: record.buildMachine,
+		builtOn: record.builtOn ?? void 0,
+		offloadedTo,
+		offloadFallback: record.offloadFallback ?? null
+	});
+	writer.close();
+	if (record.devicePlacement) facts.devicePlacement = record.devicePlacement;
+	if (json) emit(JSON.stringify({
+		...facts,
+		...links ? { links } : {},
+		...reclaimed.length ? { reclaimed } : {}
+	}));
+	else {
+		const summary = `${launchWarning ? "WARNING" : "OK"}: ${androidPackage} launched on ${host ? `${host.device?.name ?? "Android emulator"} on ${host.machine}` : serial}, ${runtimeKind === "process" ? `${variant ?? "debug"} (native process, no Metro)` : runtimeKind === "embedded-js" ? `${variant} (embedded JS, no Metro)` : `Metro port ${metroPort}`} (${cacheOutcome(record.cacheHit, remote?.name ?? providerName, offloadedTo)})`;
+		const outcome = launchWarning ? chalk.yellow(`${summary} -- ${launchWarning}`) : launchState === "unverified" ? chalk.yellow(`${summary} -- launch UNVERIFIED`) : launchState === "bundling" ? chalk.green(`${summary} -- bundle requested, still building`) : chalk.green(summary);
+		const deviceName = record.avdName || record.deviceName || serial;
+		const cacheResult = useBuildCache ? cacheOutcome(record.cacheHit, remote?.name ?? providerName, offloadedTo) : `bypassed; ${cacheOutcome(false, null, offloadedTo)}`;
+		const metroResult = runtimeKind === "process" ? "native process (no Metro)" : runtimeKind === "embedded-js" ? `embedded (${variant})` : !metroCheck ? `check skipped on port ${metroPort}` : launchState === "unverified" ? `state unverified on port ${metroPort}` : `running on port ${metroPort}${devServer ? ` (started: ${devServer.reason})` : ""}`;
+		emit([
+			outcome,
+			phaseLine("device", host ? `${deviceName} on ${host.machine}` : `${deviceName} (${serial})`),
+			phaseLine("app", androidPackage),
+			phaseLine(runtimeKind === "process" ? "runtime" : "metro", metroResult),
+			phaseLine("cache", cacheResult),
+			...ccache.status === "not-run" ? [phaseLine("compilation cache", ccacheActivityLine(ccache))] : [],
+			phaseLine("logs", logsDir || "unavailable (remote device)"),
+			...!host ? [phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`)] : []
+		].join("\n"));
+		if (links) out(chalk.dim(workspaceLinkLine(links)));
+	}
+	return facts;
+}
+function cacheOutcome(cacheHit, providerName = null, offloadedTo = null) {
+	if (cacheHit === "remote") return `cache hit from ${providerName || "the remote cache"}`;
+	if (cacheHit === "local") return "cache hit";
+	return offloadedTo ? `built on ${offloadedTo}` : "built";
+}
+function persistLastBuild({ recordBuild = recordFinishedBuild, root, record, startedAt, durationMs, status, errorCode = null, diagnostics = null, out }) {
+	const lastBuild = lastBuildRecord({
+		...record,
+		startedAt,
+		durationMs,
+		status,
+		errorCode,
+		diagnostics
+	});
+	try {
+		recordBuild(root, lastBuild);
+	} catch (err) {
+		out(phaseLine("state", chalk.yellow(`could not record lastBuild: ${err?.message || err}`)));
+	}
+	return lastBuild;
+}
+//#endregion
+export { reportAndroidResult as a, resolveAndroidRunPlan as c, persistLastBuild as i, finishAndroidUpload as n, androidDeviceSelectorRefusal as o, lastBuildRecord as r, resolveAndroidBuildPlan as s, androidFacts as t };

package/dist/{run-BtPgpKks.mjs → run-DidHghD1.mjs}

@@ -1,9 +1,8 @@
-import { j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { a as macosRuntimeClaim, i as macosProcess, r as macosLogFile, s as updateMacosRecord } from "./state-CG_OFoaA.mjs";
-import { readMacosRecord } from "@stim-cli/core/state";
+import { g as process_identity_exports, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { a as macosRuntimeClaim, i as macosProcess, r as macosLogFile, s as updateMacosRecord } from "./state-08I3hw3_.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
 import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { readMacosRecord } from "@stim-cli/core/state";
 import { StringDecoder } from "node:string_decoder";
 //#region src/macos/run.ts
 function logLines(stream, write) {
@@ -94,6 +93,7 @@ async function runMacosSupervisor(root, launchId) {
 		process.on("SIGTERM", stop);
 		process.on("SIGINT", stop);
 		log("info", `Started ${record.product} (pid ${app.pid}).`);
+		process.send?.("macos-registered", () => {});
 		await ended;
 		process.off("SIGTERM", stop);
 		process.off("SIGINT", stop);