stim 1.20.2 → 1.21.0

package/dist/native-android-D5qc3-_v.mjs

@@ -1,226 +0,0 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { $ as settingValueAt } from "./settings-B717odTD.mjs";
-import { x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { T as findBuildTool, o as androidHome } from "./android-Mz_Inn3w.mjs";
-import { i as skippedMissReason } from "./miss-reason-mKzZ4VvN.mjs";
-import { o as resolveCcache } from "./ccache-zdKiYQ3E.mjs";
-import { a as buildGradle, r as androidSdkRefusal } from "./gradle-DSrXb6lG.mjs";
-import { n as androidToolchain } from "./toolchain-DxSsNssu.mjs";
-import { i as nativeGradleTransfer, t as gradleOffloadInputs } from "./native-gradle-inputs-BsLRrl7u.mjs";
-import { n as androidProcessRuntime } from "./launch-F4sOqAhB.mjs";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/integrations/native-android.ts
-const CACHE_LIMIT = "Native Gradle inputs can include arbitrary external files and plugins; Stim artifact caching is unavailable. Offload requires a complete android.offloadInputs declaration. Gradle still owns incremental and task-cache reuse.";
-const MODEL_LIMIT = "Native Android requires AGP with androidComponents, one application module and configuration-on-demand disabled. Gradle resolves the exact variant and APK outputs during the build.";
-function refusal(reason) {
-	return {
-		code: "STIM_BUILD_FAILED",
-		reason,
-		remedy: "Select one signed standalone APK for the requested variant and target ABI in the Android application module, then retry. Stim does not sign APKs or install split APK sets."
-	};
-}
-function selectNativeApk(value, variant, abi) {
-	const model = value;
-	if (!model || model.schema !== 1 || typeof model.module !== "string" || !model.module.startsWith(":") || model.variant !== variant || typeof model.applicationId !== "string" || !/^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+$/.test(model.applicationId) || typeof model.sdkDirectory !== "string" || !isAbsolute(model.sdkDirectory) || !Array.isArray(model.elements) || !model.elements.every((element) => element && typeof element.path === "string" && isAbsolute(element.path) && element.path.endsWith(".apk") && Array.isArray(element.filters) && element.filters.every((filter) => filter && typeof filter.type === "string" && typeof filter.value === "string"))) return refusal("Gradle did not export a valid model for the requested native Android variant.");
-	const universal = model.elements.filter((element) => element.filters.length === 0);
-	const candidates = universal.length ? universal : model.elements.filter((element) => abi !== null && element.filters.length === 1 && element.filters[0].type === "ABI" && element.filters[0].value === abi);
-	if (candidates.length !== 1) return refusal(`Native variant "${variant}" has ${candidates.length} installable APK candidates for ${abi ?? "an unspecified ABI"}. Density splits and ambiguous output sets are unsupported.`);
-	return {
-		apkPath: candidates[0].path,
-		androidPackage: model.applicationId
-	};
-}
-async function locateNativeApk(modelFile, variant, abi) {
-	let value;
-	try {
-		value = JSON.parse(readFileSync(modelFile, "utf8"));
-	} catch {
-		return refusal("Gradle succeeded without exporting the native Android APK model.");
-	}
-	const located = selectNativeApk(value, variant, abi);
-	if ("code" in located) return located;
-	try {
-		if (!statSync(located.apkPath).isFile()) return refusal("The APK selected by Gradle is not a file.");
-	} catch {
-		return refusal("The APK selected by Gradle does not exist.");
-	}
-	const signer = findBuildTool(["apksigner"], { home: value.sdkDirectory });
-	if (!signer) return refusal("No Android SDK apksigner is available to verify the native APK signature.");
-	try {
-		await getExecutor().runFileAsync(signer.path, ["verify", located.apkPath], { timeoutMs: 3e4 });
-	} catch (error) {
-		return refusal(`The native APK signature could not be verified: ${error.message}`);
-	}
-	return located;
-}
-function nativeAndroidProject(root) {
-	return {
-		isExpo: false,
-		packageRemedy: "Check the applicationId reported by AGP for the selected application variant.",
-		appIds: () => ({
-			bundleId: null,
-			androidPackage: null
-		}),
-		variantProblem: () => null,
-		targets: [
-			"emulator",
-			"physical",
-			"hosted"
-		],
-		eas: false,
-		runtimeKind: () => "process",
-		plan: async () => ({ refusal: {
-			code: "STIM_BAD_ARG",
-			message: `${MODEL_LIMIT} --plan does not execute Gradle. ${CACHE_LIMIT}`,
-			remedy: "Run `stim android` with an exact --variant to resolve and build the native app."
-		} }),
-		runtime: ({ phase }) => androidProcessRuntime(async () => {
-			phase("metro", "skipped (native process)");
-			return {
-				ok: true,
-				prepared: { metroPort: null }
-			};
-		}),
-		artifact: ({ writer, buildPlan, target, out, estimates, settings }) => {
-			const variant = buildPlan.variant ?? "debug";
-			const inputs = settingValueAt(settings, "android.offloadInputs");
-			let transfer = null;
-			const modelFile = join(workspaceDir(root), "gradle-build", `native-apk-${encodeURIComponent(variant)}.json`);
-			return {
-				identity: async () => ({ cacheIneligible: CACHE_LIMIT }),
-				cache: () => {
-					throw new Error(CACHE_LIMIT);
-				},
-				prepare: async () => {},
-				reconcile: async () => ({
-					identity: null,
-					rekeyedBy: [],
-					cacheRefusal: null
-				}),
-				validate: async () => null,
-				materialize: async () => null,
-				explain: () => ({
-					reason: skippedMissReason(CACHE_LIMIT),
-					diff: null
-				}),
-				untrackedLine: () => null,
-				legacyCache: null,
-				offload: {
-					supportsUncachedArtifacts: true,
-					get unsupported() {
-						if (buildPlan.cas) return "Apple Clang CAS builds build here";
-						try {
-							gradleOffloadInputs(inputs);
-							return null;
-						} catch (error) {
-							return error.message;
-						}
-					},
-					target: () => {
-						transfer = nativeGradleTransfer(root, inputs);
-						return {
-							platform: "android",
-							native: "gradle",
-							local: androidToolchain(),
-							requires: {
-								ndk: null,
-								buildTools: null,
-								compileSdk: null
-							}
-						};
-					},
-					get request() {
-						if (!transfer) throw new Error("Native Gradle offload needs a declared source inventory.");
-						return {
-							platform: "android",
-							isExpo: false,
-							native: {
-								provider: "gradle",
-								transfer
-							},
-							android: {
-								variant,
-								abi: target.abi,
-								gradleBuildCache: buildPlan.gradleBuildCache,
-								pch: buildPlan.pch,
-								compilerCache: buildPlan.compilerCache === "none" ? "none" : "ccache"
-							}
-						};
-					},
-					unchanged: async () => transfer !== null && nativeGradleTransfer(root, inputs).digest === transfer.digest
-				},
-				compile: async () => {
-					const script = ["../shim/native-android.gradle", "../../shim/native-android.gradle"].map((path) => fileURLToPath(new URL(path, import.meta.url))).find(existsSync);
-					if (!script) throw new Error("Stim installation is missing shim/native-android.gradle.");
-					return buildGradle({
-						root,
-						logWriter: writer,
-						variant,
-						project: {
-							directory: root,
-							gradlew: join(root, process.platform === "win32" ? "gradlew.bat" : "gradlew"),
-							module: ":",
-							outputsDir: root
-						},
-						task: ":stimExportAndroidApk",
-						projectArgs: [
-							"--init-script",
-							script,
-							`-Pstim.native.variant=${variant}`,
-							`-Pstim.native.model=${modelFile}`
-						],
-						locate: () => locateNativeApk(modelFile, variant, target.abi)
-					}, {
-						estimateMs: estimates().coldBuildMs,
-						ccache: buildPlan.compilerCache === "ccache" ? resolveCcache({
-							root,
-							onNote: out
-						}) : null,
-						cas: buildPlan.cas,
-						buildCache: buildPlan.gradleBuildCache,
-						pch: buildPlan.pch,
-						compilerCacheDisabled: buildPlan.compilerCache === "none"
-					});
-				}
-			};
-		}
-	};
-}
-function nativeAndroidDoctor(root) {
-	return { inspect: () => {
-		const sdkPath = androidHome();
-		const sdk = androidSdkRefusal({
-			sdkPath,
-			sdkExists: existsSync(sdkPath),
-			hasLocalProperties: existsSync(join(root, "local.properties")),
-			localPropertiesPath: "local.properties"
-		});
-		const wrapper = join(root, process.platform === "win32" ? "gradlew.bat" : "gradlew");
-		return [
-			{
-				level: "note",
-				title: "Native Android Gradle project",
-				detail: `${MODEL_LIMIT} ${CACHE_LIMIT} Metro and EAS are unsupported; local, physical and hosted targets use native process readiness.`,
-				fix: null
-			},
-			...sdk ? [{
-				level: "cost",
-				code: "android-sdk-missing",
-				title: "No Android SDK was found",
-				detail: sdk.reason,
-				fix: sdk.remedy
-			}] : [],
-			...!existsSync(wrapper) ? [{
-				level: "cost",
-				code: "android-wrapper-missing",
-				title: "The Gradle wrapper for this host is missing",
-				detail: wrapper,
-				fix: "Restore the project Gradle wrapper."
-			}] : []
-		];
-	} };
-}
-//#endregion
-export { nativeAndroidDoctor, nativeAndroidProject };

package/dist/ndjson-Du3j0AQ9.d.mts

@@ -1,17 +0,0 @@
-import "@stim-cli/core/state";
-//#region src/ndjson.d.ts
-interface NdjsonWriter {
-  readonly file: string;
-  write(record: unknown): boolean;
-  close(): {
-    file: string;
-    written: number;
-    dropped: number;
-    lastError: Error | null;
-  };
-  readonly written: number;
-  readonly dropped: number;
-  readonly lastError: Error | null;
-}
-//#endregion
-export { NdjsonWriter as t };

package/dist/plan-C4TjdPsR.mjs

@@ -1,260 +0,0 @@
-import { V as deviceSlotPlatforms, p as getProject } from "./config-BYDxlMY3.mjs";
-import { B as remoteAndroidSetting, F as parseIosRemote, Q as settingShapeErrors, U as resolveAndroidLayout, W as resolveCacheProviderConfig, Y as settingFile, Z as settingOriginScope, a as SETTING_SHAPE_REMEDY, d as androidLayoutSetting, et as settingsLayers, f as androidLayoutSettingError, nt as unknownSettingKeys, p as cacheProviderSettingError, s as androidAvdConfigSettingError, u as androidDataPartitionSizeGbSettingError } from "./settings-B717odTD.mjs";
-import { _ as detectIsExpo } from "./project-_phNIJfs.mjs";
-import { B as ownedAvdSystemImage, F as ownedAvdDeviceProfile, K as profileNeedsFoldFeature, Q as systemImageSupportsFold, W as pickDefaultSystemImage, dt as parkedMaxSetting, j as listInstalledSystemImages, k as listAvdDeviceProfiles, t as DEFAULT_AVD_DEVICE_PROFILE } from "./android-Mz_Inn3w.mjs";
-import { d as optimizationBuildProfile, l as artifactCachePolicy, p as resolveOptimizations, u as compilerCacheFallbackMessage } from "./errors-DzkMYh8Q.mjs";
-import { r as isPhysicalDeviceRequest } from "./native-runtime-k8dTIrbK.mjs";
-import { t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-CBUAcRyQ.mjs";
-import { C as remoteAvdFlagRefusal, D as systemImageRefusal, E as resolveVariant, T as resolveSystemImage, m as deviceProfileRefusal, v as foldableImageRefusal, w as resolveDeviceProfile, y as isReleaseVariant } from "./support-DMTqj3Hm.mjs";
-import { c as readProductFlavors, s as productFlavorRefusal } from "./react-native-build-CtCccJtb.mjs";
-import { n as resolveAndroidCas, r as resolveAndroidCompilerCache } from "./android-cas-Bl-cLJBk.mjs";
-import { l as parseDeviceWait } from "./device-lease-run-Cw2M4z51.mjs";
-//#region src/integrations/android-project.ts
-var AndroidRecipeRefusal = class extends Error {
-	failure;
-	missReason;
-	constructor(failure, missReason) {
-		super(failure.message ?? failure.code);
-		this.failure = failure;
-		this.missReason = missReason;
-	}
-};
-//#endregion
-//#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, settingsContext, layout }) {
-	const { cas, optimizations: resolved } = resolveAndroidCompilerCache({
-		optimizations,
-		use: (manifest) => resolveAndroidCas(root, {
-			...process.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, 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);
-	} catch (error) {
-		return fail("STIM_BAD_ARG", `Could not configure Android build: ${error.message}`, SETTING_SHAPE_REMEDY);
-	}
-	const compilerCache = resolveCompilerCache({
-		root,
-		optimizations,
-		settingsContext,
-		layout
-	});
-	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
-		}
-	};
-}
-function resolveAndroidRunPlan({ settings, settingsContext, slot, 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 = listAvdDeviceProfiles, 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,
-		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) return fail("STIM_BAD_ARG", "--device installs on a device connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote.");
-	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) : remoteAndroidSetting(settings);
-	if (physical && remoteTarget?.kind === "machine") return fail("STIM_BAD_ARG", "--device installs on a phone connected to this machine, and --remote installs on a remote one.", "Pass only one of --device and --remote; unset android.remote for a local phone.");
-	const machine = remoteTarget?.kind === "machine" ? remoteTarget.machine : null;
-	const remoteBackend = !physical && remoteTarget?.kind === "backend" ? remoteTarget.backend : null;
-	if (!machine) {
-		const refusal = androidDeviceSelectorRefusal({
-			settingsContext,
-			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
-		}
-	};
-}
-function androidDeviceSelectorRefusal({ settingsContext, slot, systemImageFlag, deviceProfileFlag, systemImage, deviceProfile, physical, remoteBackend }, { listSystemImages = listInstalledSystemImages, listDeviceProfiles = listAvdDeviceProfiles, 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 = deviceProfileRefusal({
-		flag: deviceProfileFlag,
-		resolved: deviceProfile,
-		origin: settingOriginScope(settingsLayersForOrigin, "android.deviceProfile"),
-		physical,
-		remoteBackend,
-		listProfiles: listDeviceProfiles
-	});
-	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
-export { AndroidRecipeRefusal as i, resolveAndroidBuildPlan as n, resolveAndroidRunPlan as r, androidDeviceSelectorRefusal as t };