stim 1.20.2 → 1.21.0

package/dist/{artifact-D3czlUvT.mjs → artifact-DAuZ-FNU.mjs}

@@ -1,22 +1,24 @@
-import { j as ownership_claim_exports } from "./config-BYDxlMY3.mjs";
-import { A as providerDownloadPath, k as prepareProviderDownloadDir, v as waitForSharedBuild } from "./device-lease-BX1sJQ2E.mjs";
-import { x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { _ as stepTimer, i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BTy8hZ0F.mjs";
-import { x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { a as easAuthNote, s as isEasAuthFailureText, t as RESOLVE_TIMEOUT_MS } from "./remote-cache-OyOyVIS3.mjs";
-import { _ as requireLocalBuild, c as offloadPlacement, h as namedBuildMachine, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, p as OffloadRefusal, r as chooseBuildMachine, u as remotePhaseText } from "./client-qQAaXSUs.mjs";
-import { i as skippedMissReason } from "./miss-reason-mKzZ4VvN.mjs";
-import { t as buildPlacementRecord } from "./placement-log-MOfPVgaM.mjs";
-import { t as runArtifactLifecycle } from "./artifact-lifecycle-DzPpBYvK.mjs";
-import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine, t as CCACHE_NOT_RUN } from "./ccache-zdKiYQ3E.mjs";
-import { c as formatDiagnostic } from "./gradle-DSrXb6lG.mjs";
-import { a as PLATFORM, h as displayPath } from "./support-DMTqj3Hm.mjs";
-import { i as AndroidRecipeRefusal } from "./plan-C4TjdPsR.mjs";
+import { d as withDrainingCancellation, f as ownership_claim_exports } from "./exec-_UbtCQcG.mjs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { _ as stepTimer, i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-B1UrjZHL.mjs";
+import { en as throwIfCancelled } from "./settings-CsJDEXgK.mjs";
+import { Hn as isEasAuthFailureText, Ln as RESOLVE_TIMEOUT_MS, Vn as easAuthNote } from "./budget-Bs6SxxzO.mjs";
+import { d as runCancellationSignal, r as cancelledFailure } from "./native-run-DY_RLx3C.mjs";
+import { d as prepareProviderDownloadDir, f as providerDownloadPath } from "./build-cache-DmyR9Zzc.mjs";
+import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine, t as CCACHE_NOT_RUN } from "./ccache-BJRZ9pG3.mjs";
+import { c as offloadPlacement, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, r as chooseBuildMachine, u as remotePhaseText } from "./client-UXD70ZbM.mjs";
+import { a as requireLocalBuild, r as namedBuildMachine, t as OffloadRefusal } from "./selection-CSl9i5qU.mjs";
+import { f as formatDiagnostic } from "./react-native-build-rhk4smwQ.mjs";
+import { c as skippedMissReason } from "./prebuild-uD_ipCxF.mjs";
+import { t as buildPlacementRecord } from "./placement-log-BqGbTa61.mjs";
+import { t as acquireArtifact } from "./acquire-artifact-CD4lbiWE.mjs";
+import { a as PLATFORM, h as displayPath } from "./support-67vraa1Q.mjs";
+import { t as AndroidRecipeRefusal } from "./android-project-BCAAmMwz.mjs";
 import { rmSync } from "node:fs";
 import { join } from "node:path";
 import { machineCapacity } from "@stim-cli/core/state";
-import { createWarnOnce, resolveTieredBuild, storeTieredBuild } from "@stim-cli/cache";
 import chalk from "chalk";
+import { PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, buildResolveTimeoutMs, buildUploadTimeoutMs, createWarnOnce, resolveTieredBuild, storeTieredBuild, timeoutFromEnv } from "@stim-cli/cache";
 //#region src/commands/android/artifact.ts
 const FALLBACK_LINES = 5;
 function fail(code, message, remedy, extra = {}) {
@@ -27,10 +29,10 @@ function fail(code, message, remedy, extra = {}) {
 		extra
 	};
 }
-async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOffloadRefusal, buildPlan, cacheProviderConfig, requestedBuildCache, easBuild, androidPackage: initialPackage, record, maxBuilds, progress }, { acquireLock, releaseLock, waitForBuild, easAuth, resolveRemoteBuild, uploadRemoteBuild, loadCacheProviderModule, acquireSlot, releaseSlot, now }) {
+async function acquireAndroidArtifact({ context, root, buildLog, writer, recipe, targetOffloadRefusal, buildPlan, cacheProviderConfig, requestedBuildCache, easBuild, androidPackage: initialPackage, record, maxBuilds, progress }, { acquireLock, releaseLock, waitForBuild, easAuth, resolveRemoteBuild, uploadRemoteBuild, loadCacheProviderModule, acquireSlot, releaseSlot, now }) {
 	const { phase, out, stats, step, miss, hit: lateHit, place, waitingOn, waitingFor } = progress;
 	let fallbackMachine = null;
-	let hereReason = "no remote Mac is paired";
+	let hereReason = "no remote machine is paired";
 	let slotWaitMs;
 	const buildMachine = record.buildMachine ?? "auto";
 	const fallBack = (reason, line = reason, info = {}) => {
@@ -51,7 +53,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		phase("build", `${line} -> building here`);
 	};
 	const { variant, cache: cachePolicy } = buildPlan;
-	const signal = runCancellationSignal() ?? new AbortController().signal;
+	const signal = runCancellationSignal(context) ?? context.signal;
 	const cacheTarget = (key) => ({
 		projectRoot: root,
 		platform: "android",
@@ -63,28 +65,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	let androidPackage = initialPackage;
 	let ccacheActivity = CCACHE_NOT_RUN;
 	let phaseFailure = null;
-	let buildLock = null;
-	const releaseHeldLock = () => {
-		if (!buildLock) return;
-		const held = buildLock;
-		buildLock = null;
-		try {
-			releaseLock(held);
-		} catch (err) {
-			out(phaseLine("build", chalk.dim(`could not release the build lock at ${held.path}: ${err?.message || err}`)));
-		}
-	};
-	let buildSlot = null;
-	const releaseHeldSlot = () => {
-		if (!buildSlot) return;
-		const held = buildSlot;
-		buildSlot = null;
-		try {
-			releaseSlot(held);
-		} catch (err) {
-			out(phaseLine("build", chalk.dim(`could not release the build slot: ${err?.message || err}`)));
-		}
-	};
+	let run;
 	let hash = "";
 	let providerUpload = null;
 	let providerName = null;
@@ -92,7 +73,15 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	const cacheWarn = createWarnOnce((line) => phase("cache", chalk.yellow(line)));
 	const loadTieredProvider = cachePolicy.remote && cacheProviderConfig ? () => providerLoad ??= loadCacheProviderModule({
 		projectRoot: root,
-		config: cacheProviderConfig
+		config: cacheProviderConfig,
+		timeoutMs: timeoutFromEnv(PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, context.env)
+	}).then((loaded) => {
+		if (!loaded.provider || !recipe.providerCache) return loaded;
+		const builds = recipe.providerCache(loaded.provider);
+		return {
+			...loaded,
+			provider: builds ? { builds } : {}
+		};
 	}) : null;
 	let cacheKey = "";
 	let storeHash = "";
@@ -140,7 +129,8 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		record.cacheKey = cacheKey;
 		storeHash = hash;
 		storeKey = cacheKey;
-		const found = await resolveTieredBuild({
+		const found = await withDrainingCancellation(context, signal, () => resolveTieredBuild({
+			timeoutMs: buildResolveTimeoutMs(context.env),
 			local: recipe.cache(),
 			loadProvider: loadTieredProvider,
 			target: {
@@ -149,10 +139,11 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				key: cacheKey
 			},
 			destinationDir: providerDownloadPath(workspaceDir(root)),
-			ensureDestination: prepareProviderDownloadDir,
+			ensureDestination: (dir) => prepareProviderDownloadDir(dir, root),
 			skipRead: !useBuildCache,
-			warn: cacheWarn
-		});
+			warn: cacheWarn,
+			signal
+		}));
 		const cached = found?.tier === "local" ? found.path : null;
 		record.cacheHit = cached ? "local" : false;
 		record.cacheSkipped = !useBuildCache;
@@ -175,7 +166,8 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			if (loaded?.unavailable) phase("cache", chalk.yellow(`provider not usable: ${loaded.unavailable}`));
 			else if (loaded?.provider) remote = loaded;
 			if (remote?.name === "eas") {
-				const auth = easAuth({
+				const auth = await easAuth({
+					context,
 					projectRoot: root,
 					owner: loaded?.owner || null
 				});
@@ -187,6 +179,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		if (remote && useBuildCache) {
 			const remoteTimer = stepTimer(now);
 			const hit = await resolveRemoteBuild({
+				context,
 				logWriter: writer,
 				provider: remote.provider,
 				platform: PLATFORM,
@@ -203,6 +196,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 						overwrite: false
 					}) ?? null;
 				} catch (err) {
+					throwIfCancelled(signal, "build cache backfill");
 					phase("cache", chalk.yellow(`remote hit could not be stored locally: ${err?.message || err}`));
 				}
 				apkPath = stored || hit.appPath;
@@ -224,16 +218,9 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	let releasedWait = null;
 	async function awaitSharedBuild() {
 		if (!useBuildCache) return null;
-		const shared = await waitForSharedBuild({
-			platform: PLATFORM,
+		const shared = await run.claimSharedBuild({
 			key: cacheKey,
 			fingerprint: hash,
-			root,
-			logFile: buildLog,
-			command: "stim android",
-			acquire: acquireLock,
-			wait: waitForBuild,
-			now,
 			phase: (text) => {
 				step("wait");
 				phase("build", text);
@@ -247,7 +234,6 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			phaseFailure = fail(code, message, remedy, { lastBuildStatus: true });
 			throw new AndroidRecipeRefusal(phaseFailure);
 		}
-		buildLock = shared.lock;
 		releasedWait = shared.released;
 		if (shared.hit) {
 			apkPath = shared.hit.path;
@@ -256,26 +242,17 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		}
 		return apkPath;
 	}
-	let swapDir = null;
-	const releaseArtifact = () => {
-		if (!swapDir) return;
-		try {
-			rmSync(swapDir, {
-				recursive: true,
-				force: true
-			});
-			swapDir = null;
-		} catch (error) {
-			out(phaseLine("cleanup", chalk.yellow(`could not remove the temporary APK: ${error.message}`)));
-		}
-	};
 	const installableCachedApk = async (key, cachedPath) => {
 		const prepared = await recipe.materialize(key, cachedPath);
 		if (!prepared) {
 			swapFellBack = true;
 			return null;
 		}
-		swapDir = prepared.directory;
+		if (prepared.directory) run.own(prepared.directory);
+		if (prepared.androidPackage) {
+			androidPackage = prepared.androidPackage;
+			record.bundleId = androidPackage;
+		}
 		return prepared.apkPath;
 	};
 	async function prepareCachedArtifact(cachedPath) {
@@ -316,16 +293,15 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		requireLocalBuild(buildMachine);
 		if (!maxBuilds) return true;
 		try {
-			buildSlot = await acquireSlot({
+			slotWaitMs = (await run.takeBuildSlot({
+				signal,
 				automatic: buildMachine === "auto",
 				max: maxBuilds,
-				root,
-				logFile: buildLog,
 				out,
 				waitingFor: (info) => waitingFor?.(info, "build-slot")
-			});
-			slotWaitMs = buildSlot.slotWaitMs;
+			})).slotWaitMs;
 		} catch (err) {
+			throwIfCancelled(signal, "Android build");
 			requireLocalBuild(buildMachine);
 			const refusal = (0, ownership_claim_exports.claimFailure)(err, "stim android");
 			if (refusal) {
@@ -336,7 +312,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		}
 		return true;
 	}
-	/** Whether this build should leave this Mac, before any machine is asked; null builds here. */
+	/** Whether this build should leave this machine, before any machine is asked; null builds here. */
 	function placeBuild() {
 		if (cacheIneligible && !recipe.offload?.supportsUncachedArtifacts) {
 			if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, cacheIneligible);
@@ -376,13 +352,12 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			machines
 		};
 	}
-	const openOffload = { choice: null };
 	/** Asks the paired machines once the post-mutation key is known; null builds here. */
 	async function chooseMachine(candidate) {
 		let asked = [];
 		let target;
 		try {
-			target = recipe.offload.target();
+			target = await recipe.offload.target();
 		} catch (error) {
 			fallBack(error.message);
 			return null;
@@ -406,7 +381,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			});
 			return null;
 		}
-		openOffload.choice = choice;
+		run.openOffload(() => closeOffload(choice));
 		writer.write(buildPlacementRecord({
 			platform: PLATFORM,
 			buildMachine,
@@ -421,7 +396,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 	}
 	/** Builds on the chosen machine and stores the APK under the post-mutation key; false builds here instead unless a machine was named. */
 	async function compileElsewhere(choice, candidate) {
-		const uncached = Boolean(cacheIneligible && recipe.offload?.supportsUncachedArtifacts);
+		const uncached = Boolean(recipe.offload?.uncachedArtifacts || cacheIneligible && recipe.offload?.supportsUncachedArtifacts);
 		if ((!storeKey || !storeHash) && !uncached) {
 			const reason = "the build fingerprint or cache key is unavailable";
 			if (namedBuildMachine(buildMachine)) fallBack(reason, reason, { machine: choice.machine });
@@ -438,7 +413,7 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			return false;
 		}
 		const stagingDir = join(workspaceDir(root), "offload", PLATFORM);
-		if (uncached) swapDir = stagingDir;
+		const disownStaging = uncached ? run.own(stagingDir) : null;
 		const outcome = await offloadBuild({
 			choice,
 			expectedFingerprint: uncached ? null : storeHash,
@@ -475,7 +450,6 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				else {
 					stored = outcome.artifactPath;
 					androidPackage = outcome.androidPackage;
-					swapDir = stagingDir;
 				}
 			} else try {
 				stored = await recipe.cache().store({
@@ -487,15 +461,16 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 				reason = `could not store the APK: ${err?.message || err}`;
 			}
 		}
-		try {
-			if (!uncached || !stored) {
+		if (!uncached || !stored) {
+			disownStaging?.();
+			try {
 				rmSync(stagingDir, {
 					recursive: true,
 					force: true
 				});
-				if (swapDir === stagingDir) swapDir = null;
-			}
-		} catch {}
+			} catch {}
+		}
+		throwIfCancelled(signal, "offloaded build cache copy");
 		step("compile");
 		if (!outcome.ok || !stored) {
 			const why = reason ?? "the APK was not stored";
@@ -514,6 +489,12 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			return false;
 		}
 		const { timings } = outcome;
+		if (uncached) {
+			record.fingerprint = null;
+			record.cacheKey = null;
+			record.cacheHit = false;
+			record.cacheSkipped = true;
+		}
 		apkPath = stored;
 		handoff = outcome.handoff ?? null;
 		record.builtOn = outcome.machine;
@@ -660,7 +641,8 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 		if (cachePolicy.write) {
 			const local = recipe.cache(true);
 			try {
-				const stored = await storeTieredBuild({
+				const stored = await withDrainingCancellation(context, signal, () => storeTieredBuild({
+					timeoutMs: buildUploadTimeoutMs(context.env),
 					local,
 					loadProvider: loadTieredProvider,
 					target: {
@@ -670,15 +652,20 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 					},
 					sourcePath: artifactPath,
 					overwrite: !useBuildCache || swapFellBack,
-					warn: cacheWarn
-				});
-				providerUpload = stored.providerUpload;
+					warn: cacheWarn,
+					signal
+				}));
+				const pending = stored.providerUpload;
+				providerUpload = pending ? withDrainingCancellation(context, signal, () => pending) : null;
+				providerUpload?.catch(() => {});
 				providerName = stored.providerName ?? providerName;
 			} catch (err) {
+				throwIfCancelled(signal, "build cache storage");
 				phase("cache", chalk.yellow(`could not store the build: ${err?.message || err}`));
 			}
 		}
 		if (remote) uploadPending = uploadRemoteBuild({
+			context,
 			logWriter: writer,
 			provider: remote.provider,
 			platform: PLATFORM,
@@ -688,73 +675,96 @@ async function acquireAndroidArtifact({ root, buildLog, writer, recipe, targetOf
 			runOptions: recipe.legacyCache?.runOptions ?? null
 		});
 	}
-	try {
-		apkPath = await runArtifactLifecycle({
-			resolve: async () => {
-				if (!await resolveInitialFingerprint()) throw new AndroidRecipeRefusal(phaseFailure);
-				if (easBuild) return {
-					kind: "ready",
-					artifact: apkPath
-				};
-				await resolveRemoteArtifact();
-				if (apkPath) return {
-					kind: "cached",
-					artifact: apkPath
-				};
-				miss(reasonForMiss([]).reason);
-				return { kind: "miss" };
-			},
-			claim: useBuildCache ? awaitSharedBuild : void 0,
-			reuse: async (cached) => {
-				apkPath = await prepareCachedArtifact(cached);
-				if (apkPath) lateHit();
-				else if (swapFellBack) miss(reasonForMiss([]).reason);
-				return apkPath;
-			},
-			build: {
-				placement: {
-					select: placeBuild,
-					acquire: acquireRemoteArtifact
+	const acquired = await acquireArtifact({
+		platform: PLATFORM,
+		command: "stim android",
+		lifecycle: (driver) => {
+			run = driver;
+			return {
+				resolve: async () => {
+					if (!await resolveInitialFingerprint()) throw new AndroidRecipeRefusal(phaseFailure);
+					if (easBuild) return {
+						kind: "ready",
+						artifact: apkPath
+					};
+					await resolveRemoteArtifact();
+					if (apkPath) return {
+						kind: "cached",
+						artifact: apkPath
+					};
+					miss(reasonForMiss([]).reason);
+					return { kind: "miss" };
 				},
-				admit: async () => {
-					if (!await takeBuildSlot()) throw new AndroidRecipeRefusal(phaseFailure);
+				claim: useBuildCache ? awaitSharedBuild : void 0,
+				reuse: async (cached) => {
+					apkPath = await prepareCachedArtifact(cached);
+					if (apkPath) lateHit();
+					else if (swapFellBack) miss(reasonForMiss([]).reason);
+					return apkPath;
 				},
-				prepare: prepareSource,
-				revalidate: revalidateSource,
-				compile: compileHere,
-				validate: validateCompiled,
-				store: storeArtifact
-			},
-			release: () => {
-				if (openOffload.choice) closeOffload(openOffload.choice);
-				releaseHeldLock();
-				releaseHeldSlot();
-			}
-		});
-	} catch (error) {
-		releaseArtifact();
-		if (error instanceof OffloadRefusal) {
-			const { code, message, remedy } = error;
-			return {
-				ok: false,
-				failure: fail(code, message, remedy, { lastBuildStatus: true }),
-				ccache: ccacheActivity
+				build: {
+					placement: {
+						select: placeBuild,
+						acquire: acquireRemoteArtifact
+					},
+					admit: async () => {
+						if (!await takeBuildSlot()) throw new AndroidRecipeRefusal(phaseFailure);
+					},
+					prepare: prepareSource,
+					revalidate: revalidateSource,
+					compile: compileHere,
+					validate: validateCompiled,
+					store: storeArtifact
+				}
 			};
+		},
+		settleFailed: async () => {
+			await Promise.allSettled([uploadPending, providerUpload]);
+		},
+		refuse: (error) => {
+			if (error instanceof OffloadRefusal) {
+				const { code, message, remedy } = error;
+				return fail(code, message, remedy, { lastBuildStatus: true });
+			}
+			if (error instanceof AndroidRecipeRefusal) return error.failure;
+			const cancelled = cancelledFailure(context, PLATFORM, {
+				code: "STIM_CANCELLED",
+				message: "during app preparation"
+			});
+			return cancelled ? fail(cancelled.code, cancelled.message, cancelled.remedy, { lastBuildStatus: true }) : null;
+		},
+		releaseFailed: (subject, err) => out(phaseLine("build", chalk.dim(`could not release ${subject}: ${err?.message || err}`))),
+		temporaryReleaseFailed: (error) => out(phaseLine("cleanup", chalk.yellow(`could not remove the temporary APK: ${error.message}`)))
+	}, {
+		root,
+		logFile: buildLog,
+		deps: {
+			acquireBuildLock: acquireLock,
+			releaseBuildLock: releaseLock,
+			waitForBuild,
+			acquireBuildSlot: acquireSlot,
+			releaseBuildSlot: releaseSlot,
+			now
 		}
-		if (error instanceof AndroidRecipeRefusal) return {
-			ok: false,
-			failure: error.failure,
-			ccache: ccacheActivity
-		};
-		throw error;
-	}
+	});
+	if (!acquired.ok) return {
+		ok: false,
+		failure: acquired.failure,
+		ccache: ccacheActivity
+	};
 	return {
 		ok: true,
 		artifact: {
-			apkPath,
+			apkPath: acquired.artifact,
 			handoff,
 			androidPackage,
-			release: releaseArtifact,
+			release: async () => {
+				try {
+					await Promise.allSettled([providerUpload, remote?.provider && "easCli" in remote.provider ? uploadPending : null]);
+				} finally {
+					acquired.release();
+				}
+			},
 			waitedForBuild,
 			ccache: ccacheActivity,
 			uploadPending,

package/dist/{browser-web-CA-F1GQo.mjs → browser-web-QQzVjz3O.mjs}

@@ -1,23 +1,25 @@
-import { p as getProject } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { a as SETTING_SHAPE_REMEDY, j as metroPortSetting, rt as webSettings } from "./settings-B717odTD.mjs";
-import { r as readWorkspaceState, w as workspaceLogsDir, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { _ as detectIsExpo, y as isPackageResolvable } from "./project-_phNIJfs.mjs";
-import { u as resolveProjectMetro } from "./metro-DnCEjCxs.mjs";
-import { P as resolveSupervisorTarget, _ as teardownBrowserHeld } from "./workspaces-C36s2jb9.mjs";
-import { a as withWorkspaceProcessLock, i as reserveBrowserPort, n as getNamedPort } from "./named-ports-4WopRPg-.mjs";
-import { t as cancellableSleep } from "./cancellation-C_22VQTH.mjs";
-import { s as readNdjsonGenerations } from "./ndjson-GOnbyvso.mjs";
-import { o as resolveWorkspaceMetroPort } from "./start-BWqzODpb.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-B9C_zeQC.mjs";
-import { d as webLogFile, o as readWebRecord, p as webSupervisorLogFile, s as updateWebRecord } from "./state-D1Icyjlu.mjs";
-import { c as readMetroRecords } from "./launch-verify-B6Q8hZP-.mjs";
-import { n as sendToOwnedPage, t as liveWebRecord } from "./page-DRHy329N.mjs";
-import { a as findChrome, t as CHROME_INSTALL_REMEDY } from "./chrome-BnzZMqsR.mjs";
-import { mkdirSync, openSync } from "node:fs";
+import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { d as workspaceDir, m as workspaceLogsDir } from "./paths-DQtTgsBf.mjs";
+import { p as getProject } from "./config-CYcBF478.mjs";
+import { l as phaseLine } from "./command-output-B1UrjZHL.mjs";
+import { r as readWorkspaceState } from "./workspace-state-Cjuigeeu.mjs";
+import { Qt as cancellableSleep, a as SETTING_SHAPE_REMEDY, at as webSettings, j as metroPortSetting } from "./settings-CsJDEXgK.mjs";
+import { b as isPackageResolvable, v as detectIsExpo } from "./project-BZNjmW_8.mjs";
+import { s as readNdjsonGenerations } from "./ndjson-CgE_o3Dl.mjs";
+import { f as resolveProjectMetro } from "./metro-DEXpIhHC.mjs";
+import { f as webLogFile, m as webSupervisorLogFile, o as readWebRecord, s as updateWebRecord } from "./state-C4ZtUisW.mjs";
+import { en as readMetroRecords } from "./budget-Bs6SxxzO.mjs";
+import { T as teardownBrowserHeld, m as resolveSupervisorTarget } from "./workspaces-BccMFmGQ.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
+import { i as reserveBrowserPort, n as getNamedPort } from "./named-ports-BWTzt6mu.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-CPaHeYqj.mjs";
+import { a as findChrome, t as CHROME_INSTALL_REMEDY } from "./chrome-B6tfCta1.mjs";
+import { o as resolveWorkspaceMetroPort } from "./start-7lpH7hmN.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-DFRyG1_o.mjs";
 import { randomUUID } from "node:crypto";
+import { mkdirSync, openSync } from "node:fs";
+import { ambientEnv } from "@stim-cli/core";
 import chalk from "chalk";
 //#region src/web/launch.ts
 const PORT_PLACEHOLDER = /\{port:([^}]*)\}/g;
@@ -183,7 +185,7 @@ function startSupervisor(root, { url, port, config, launchId }) {
 			cwd: root,
 			stdio: "ignore",
 			env: {
-				...process.env,
+				...ambientEnv(),
 				...launcher.env
 			},
 			windowsHide: true
@@ -198,7 +200,7 @@ function startSupervisor(root, { url, port, config, launchId }) {
 			fd,
 			fd
 		],
-		env: process.env
+		env: ambientEnv()
 	});
 	child.unref?.();
 	return child;
@@ -277,13 +279,13 @@ function failure(code, message, remedy) {
 	};
 }
 function browserWebProject(root) {
-	return { runtime: ({ settings, headed, note }) => ({
+	return { runtime: ({ settings, headed, note, context }) => ({
 		async prepare() {
 			const web = webSettings(settings);
 			const usesMetro = web.url === null || web.url.includes("{port:metro}");
-			const pin = usesMetro ? metroPortSetting(settings) : null;
+			const pin = usesMetro ? metroPortSetting(settings, context?.env) : null;
 			if (pin?.error) return failure("STIM_BAD_ARG", pin.error, SETTING_SHAPE_REMEDY);
-			const chrome = findChrome();
+			const chrome = findChrome({ env: context?.env });
 			if (!chrome) return failure("STIM_WEB_NO_CHROME", "Google Chrome or Chromium is not installed.", CHROME_INSTALL_REMEDY);
 			if (web.url === null && !detectIsExpo(root)) return failure("STIM_WEB_NO_URL", "This is not an Expo app, so Stim does not know which page to open.", "Start your web dev server on a named port, then set the page: `stim settings set web.url 'http://localhost:{port:web}/' --scope workspace`. See `stim guide web`.");
 			if (web.url === null && !isPackageResolvable(root, "react-native-web")) return failure("STIM_WEB_DEPS_MISSING", "This Expo app cannot render on the web: react-native-web is not installed.", `Run \`${EXPO_WEB_DEPENDENCIES}\` and \`stim start\`, then run \`stim web\` again.`);