stim 1.21.0 → 1.23.0

package/dist/operation-exec-BW0em61G.mjs

@@ -0,0 +1,171 @@
+import { m as operationState, r as WorkspaceProcessCleanupError, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { sep } from "node:path";
+//#region src/cancellation.ts
+function cancelledError(what, cause) {
+	return Object.assign(new Error(`The ${what} was cancelled.`, cause === void 0 ? void 0 : { cause }), { code: "STIM_CANCELLED" });
+}
+function throwIfCancelled(signal, what) {
+	if (signal?.aborted) throw cancelledError(what);
+}
+function cancellableSleep(ms, { signal, what = "wait", ref = true } = {}) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(cancelledError(what));
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(cancelledError(what));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (!ref) timer.unref();
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/workspace/git.ts
+const GIT_TIMEOUT_MS = 1e4;
+const GIT_CONCURRENCY = 6;
+function gitCall(cwd, args, { write, signal: _signal, timeoutMs = GIT_TIMEOUT_MS, ...opts }) {
+	return {
+		args: [
+			...write ? [] : ["--no-optional-locks"],
+			"-C",
+			cwd,
+			...args
+		],
+		opts: {
+			cwd,
+			...opts,
+			timeoutMs
+		}
+	};
+}
+/** Runs git in `cwd`, bounded by `timeoutMs` (10 s by default); throws like `runFile`. */
+function git(cwd, args, opts = {}) {
+	const call = gitCall(cwd, args, opts);
+	return getExecutor().runFile("git", call.args, call.opts);
+}
+/** `git`, returning null instead of throwing. */
+function gitQuiet(cwd, args, opts = {}) {
+	const call = gitCall(cwd, args, opts);
+	return getExecutor().runFileQuiet("git", call.args, call.opts);
+}
+const queue = [];
+let running = 0;
+/** `git` without blocking the event loop, at most six at a time; the budget starts when the call leaves the queue. */
+async function gitAsync(cwd, args, opts = {}) {
+	const signal = opts.signal ?? getExecutor().reportSignal?.();
+	signal?.throwIfAborted();
+	if (running < GIT_CONCURRENCY) running++;
+	else await new Promise((resolve, reject) => {
+		const proceed = () => {
+			signal?.removeEventListener("abort", cancel);
+			resolve();
+		};
+		const cancel = () => {
+			const index = queue.indexOf(proceed);
+			if (index !== -1) queue.splice(index, 1);
+			reject(signal?.reason);
+		};
+		queue.push(proceed);
+		signal?.addEventListener("abort", cancel, { once: true });
+		if (signal?.aborted) cancel();
+	});
+	let cleanupFailed = false;
+	try {
+		signal?.throwIfAborted();
+		const call = gitCall(cwd, args, opts);
+		return await getExecutor().runFileAsync("git", call.args, {
+			...call.opts,
+			signal
+		});
+	} catch (error) {
+		cleanupFailed = error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error;
+		throw error;
+	} finally {
+		const next = queue.shift();
+		if (next) next();
+		else running--;
+		if (!cleanupFailed) signal?.throwIfAborted();
+	}
+}
+/** `gitAsync`, returning null for ordinary failures; cancellation and unresolved cleanup reject. */
+async function gitQuietAsync(cwd, args, opts = {}) {
+	try {
+		return await gitAsync(cwd, args, opts);
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		(opts.signal ?? getExecutor().reportSignal?.())?.throwIfAborted();
+		return null;
+	}
+}
+//#endregion
+//#region src/workspace/git-read.ts
+function childEnvironment(env) {
+	return {
+		env: Object.fromEntries(Object.entries(env).flatMap(([name, value]) => value === void 0 ? [] : [[name, value]])),
+		omitEnv: Object.keys(process.env).filter((name) => env[name] === void 0)
+	};
+}
+function killOnAbort(signal) {
+	return (child) => {
+		if (!signal || getExecutor().reportSignal?.()) return;
+		if (signal.aborted) return void child.kill("SIGKILL");
+		const kill = () => child.kill("SIGKILL");
+		signal.addEventListener("abort", kill, { once: true });
+		child.once("close", () => signal.removeEventListener("abort", kill));
+	};
+}
+/** `git rev-parse <args>` in `cwd` as a native path, or null; Git runs with exactly `env` and dies when `signal` aborts. */
+function gitPath(cwd, args, env, signal) {
+	return gitAsync(cwd, ["rev-parse", ...args], {
+		...childEnvironment(env),
+		signal
+	}).then((out) => {
+		const path = out.trim();
+		if (!path) return null;
+		return sep === "/" ? path : path.replaceAll("/", sep);
+	}, () => null);
+}
+//#endregion
+//#region src/engine/operation-exec.ts
+async function runOperationFile(context, executor, file, args, options) {
+	const signal = context ? operationState(context).runSignal ?? context.signal : options.signal;
+	throwIfCancelled(signal, file);
+	const environment = context ? childEnvironment(context.env) : {
+		env: {},
+		omitEnv: []
+	};
+	const output = await executor.runFileAsync(file, args, {
+		...environment,
+		...options,
+		...context ? { env: {
+			...environment.env,
+			...options.env
+		} } : {},
+		omitEnv: [...environment.omitEnv.filter((name) => options.env?.[name] === void 0), ...options.omitEnv ?? []],
+		declareFor: context,
+		signal
+	});
+	throwIfCancelled(signal, file);
+	return output;
+}
+/** Contextual probes return null for ordinary failures and propagate cancellation or unresolved cleanup; other calls retain the executor's quiet behavior. */
+async function runOperationFileQuiet(context, executor, file, args, options) {
+	const signal = context ? operationState(context).runSignal ?? context.signal : options.signal;
+	signal?.throwIfAborted();
+	try {
+		const output = context ? await runOperationFile(context, executor, file, args, options) : await executor.runFileQuietAsync(file, args, options);
+		options.signal?.throwIfAborted();
+		signal?.throwIfAborted();
+		return output;
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		options.signal?.throwIfAborted();
+		signal?.throwIfAborted();
+		return null;
+	}
+}
+//#endregion
+export { killOnAbort as a, gitQuiet as c, cancelledError as d, throwIfCancelled as f, gitPath as i, gitQuietAsync as l, runOperationFileQuiet as n, git as o, childEnvironment as r, gitAsync as s, runOperationFile as t, cancellableSleep as u };

package/dist/{ownership-DEmM5vhh.mjs → ownership-C5fo5Edb.mjs}

@@ -1,6 +1,6 @@
-import { p as process_identity_exports } from "./exec-_UbtCQcG.mjs";
-import { c as withWorkspaceStateLock, d as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-Cjuigeeu.mjs";
-import { l as pidExists } from "./metro-DEXpIhHC.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { c as withWorkspaceStateLock, d as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-U08dEzhG.mjs";
+import { c as pidExists } from "./metro-DiXtA3Ty.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {

package/dist/{page-CPaHeYqj.mjs → page-DBL2PiUU.mjs}

@@ -1,6 +1,6 @@
-import { p as process_identity_exports } from "./exec-_UbtCQcG.mjs";
-import { en as throwIfCancelled } from "./settings-CsJDEXgK.mjs";
-import { t as connectOwnedBrowser } from "./cdp-CWmIUMbw.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { t as connectOwnedBrowser } from "./cdp-3fwICjzi.mjs";
 //#region src/web/page.ts
 /** The record of a verified live browser: its supervisor and Chrome are the processes the record names. */
 function liveWebRecord(record) {
@@ -15,6 +15,7 @@ const NAVIGATE_ACK_MS = 1e3;
 */
 async function sendToOwnedPage(record, method, params = {}, signal) {
 	const cdp = await connectOwnedBrowser(record.cdpPort, record.chromeProcess.pid, signal);
+	let navigateTimer;
 	try {
 		const { targetInfo } = await cdp.send("Target.getTargetInfo", { targetId: record.targetId });
 		throwIfCancelled(signal, "browser operation");
@@ -26,10 +27,13 @@ async function sendToOwnedPage(record, method, params = {}, signal) {
 		const reply = cdp.send(method, params, sessionId);
 		if (method === "Page.navigate") {
 			reply.catch(() => {});
-			await Promise.race([reply, new Promise((resolve) => setTimeout(resolve, NAVIGATE_ACK_MS))]);
+			await Promise.race([reply, new Promise((resolve) => {
+				navigateTimer = setTimeout(resolve, NAVIGATE_ACK_MS);
+			})]);
 		} else await reply;
 		return targetInfo.url;
 	} finally {
+		clearTimeout(navigateTimer);
 		cdp.close();
 	}
 }

package/dist/{placement-log-BqGbTa61.mjs → placement-log-BnGgJRRZ.mjs}

@@ -1,4 +1,4 @@
-import { n as buildPlacementSettings } from "./selection-CSl9i5qU.mjs";
+import { n as buildPlacementSettings } from "./selection-DSMbWEX2.mjs";
 //#region src/placement-log.ts
 /** `machine` is `local` when the run stays on this machine. */
 function placementRecord(input) {

package/dist/{plan-placement-Bwj-IjY1.mjs → plan-placement-BU42oOyT.mjs}

@@ -1,6 +1,6 @@
-import { d as hostingMachines } from "./selection-CSl9i5qU.mjs";
-import { r as readHostedNative } from "./ios-state-DvFX-K_l.mjs";
-import { i as probeHost, n as automaticDevicePlacement } from "./eas-fallback-DJwZpy0c.mjs";
+import { d as hostingMachines } from "./selection-DSMbWEX2.mjs";
+import { r as readHostedNative } from "./ios-state-Dtw5K2aI.mjs";
+import { i as probeHost, n as automaticDevicePlacement } from "./eas-fallback-DV3Wytf1.mjs";
 import { automaticMachineEnabled } from "@stim-cli/core/state";
 //#region src/device-host/plan-placement.ts
 /**
@@ -9,10 +9,10 @@ import { automaticMachineEnabled } from "@stim-cli/core/state";
 * give; `auto` repeats the placement decision a run makes now and, when that stays on this machine, notes any Mac
 * whose device would key differently. The result predicts the cache key only; a run reads its own device.
 */
-async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, eas, deps = {} }) {
-	const { automatic = automaticDevicePlacement, probe = probeHost, machines = hostingMachines } = deps;
+async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, eas, deps = {}, operation }) {
+	const { automatic = automaticDevicePlacement, probe = probeHost, machines = () => hostingMachines(void 0, operation?.signal) } = deps;
 	const named = async (name) => {
-		const result = await probe(name, platform, selectors);
+		const result = await probe(name, platform, selectors, void 0, operation?.signal);
 		if ("failure" in result.probe) return {
 			kind: "unknown",
 			reason: `${name} did not give a ${platform} device (${result.probe.failure})`
@@ -38,6 +38,7 @@ async function planHostedDevice({ root, slot, platform, machine, selectors, same
 			platform,
 			selectors,
 			noWait: false,
+			signal: operation?.signal,
 			...eas ? { eas } : {}
 		}, {
 			read: () => ({}),
@@ -52,8 +53,10 @@ async function planHostedDevice({ root, slot, platform, machine, selectors, same
 			choice: placed.target.choice,
 			placement: `on ${placed.target.host.machine}, as auto would now`
 		};
-		const names = (machines() ?? []).filter((name) => automaticMachineEnabled("device", name));
-		const differs = (await Promise.all(names.map((name) => probe(name, platform, selectors)))).flatMap(({ probe: each }) => "offer" in each && each.offer.choice && sameKey(each.offer.choice) === false ? [each.machine] : []);
+		const names = (await machines() ?? []).filter((name) => automaticMachineEnabled("device", name));
+		operation?.signal.throwIfAborted();
+		const offers = await Promise.all(names.map((name) => probe(name, platform, selectors, void 0, operation?.signal)));
+		const differs = (await Promise.all(offers.map(async ({ probe: each }) => "offer" in each && each.offer.choice && await sameKey(each.offer.choice) === false ? [each.machine] : []))).flat();
 		if (differs.length) return {
 			kind: "local",
 			placement: `this machine; auto may use ${differs.join(", ")}, which builds for another architecture, so its key differs`
@@ -63,6 +66,7 @@ async function planHostedDevice({ root, slot, platform, machine, selectors, same
 			placement: names.length ? `this machine; auto may use ${names.join(", ")}` : "this machine"
 		};
 	} catch (error) {
+		operation?.signal.throwIfAborted();
 		return {
 			kind: "unknown",
 			reason: error.message

package/dist/{ports-D-MmCTdv.mjs → ports-BSmQKzW7.mjs}

@@ -1,6 +1,6 @@
-import { p as getProject } from "./config-CYcBF478.mjs";
-import { n as findCommandWorkspace } from "./project-BZNjmW_8.mjs";
-import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-BWTzt6mu.mjs";
+import { p as getProject } from "./config-DlrsduwG.mjs";
+import { n as findCommandWorkspace } from "./project-CTLNHCfE.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-DkEzOfzO.mjs";
 //#region src/commands/ports.ts
 async function inProject(action) {
 	try {

package/dist/{prebuild-uD_ipCxF.mjs → prebuild-BFm63bQ0.mjs}

@@ -1,13 +1,13 @@
-import { s as spawnDeclared, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { d as spawnDeclared, t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { i as sharedBuildCache } from "./paths-DQtTgsBf.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { o as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-Cjuigeeu.mjs";
-import { bt as gitCommonDirOnDisk } from "./settings-CsJDEXgK.mjs";
-import { t as git } from "./git-C3iTsJaZ.mjs";
-import { v as detectIsExpo } from "./project-BZNjmW_8.mjs";
-import { Zn as remoteCliInvocation } from "./budget-Bs6SxxzO.mjs";
-import { a as diffFingerprintSources, v as storedSources } from "./build-cache-DmyR9Zzc.mjs";
-import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-DT_F_uVI.mjs";
+import { o as git, s as gitAsync } from "./operation-exec-BW0em61G.mjs";
+import { o as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { yt as gitCommonDirOnDisk } from "./settings-C7O8A6ZI.mjs";
+import { v as detectIsExpo } from "./project-CTLNHCfE.mjs";
+import { Zn as remoteCliInvocation } from "./budget-DnPX3DXj.mjs";
+import { a as diffFingerprintSources, v as storedSources } from "./build-cache-Dv7RN200.mjs";
+import { i as expoBinRefusal, o as expoSdkMajor, r as expoBinPath } from "./server-expo-D9lEz4aq.mjs";
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { ambientContext } from "@stim-cli/core";
@@ -270,6 +270,10 @@ function prebuildRecord(state) {
 	const record = state?.prebuild;
 	return record && typeof record === "object" ? record : {};
 }
+function unreadableGitTracksNativeDir(error) {
+	if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+	return !/not a git repository \(or any (of the parent directories|parent up to mount point)/.test(error instanceof Error ? error.message : String(error));
+}
 function gitTracksNativeDir(root, platform) {
 	try {
 		return git(root, [
@@ -281,22 +285,53 @@ function gitTracksNativeDir(root, platform) {
 			LANGUAGE: "C"
 		} }).trim() !== "";
 	} catch (error) {
-		if (error?.code === "ENOENT") return false;
-		return !/not a git repository \(or any (of the parent directories|parent up to mount point)/.test(String(error?.message));
+		return unreadableGitTracksNativeDir(error);
 	}
 }
-function planPrebuild(root, platform, { isExpo, fingerprint, sources }) {
+function prebuildInputs(root, platform, { isExpo, fingerprint, sources }) {
 	const nativeDirExists = existsSync(nativeDir(root, platform));
 	const fingerprinted = nativeDirInFingerprint(sources, platform);
 	const generatedFrom = prebuildRecord(readWorkspaceState$1(root))[platform];
-	return prebuildAction({
+	return {
 		isExpo,
 		nativeDirExists,
 		nativeDirFingerprinted: fingerprinted,
-		nativeDirTracked: nativeDirExists && !fingerprinted && gitTracksNativeDir(root, platform),
 		generatedFrom: typeof generatedFrom === "string" ? generatedFrom : null,
 		fingerprint
+	};
+}
+function planPrebuild(root, platform, options) {
+	const inputs = prebuildInputs(root, platform, options);
+	return prebuildAction({
+		...inputs,
+		nativeDirTracked: inputs.nativeDirExists && !inputs.nativeDirFingerprinted && gitTracksNativeDir(root, platform)
+	});
+}
+async function planPrebuildAsync(root, platform, options, signal) {
+	signal?.throwIfAborted();
+	const untracked = prebuildAction({
+		...prebuildInputs(root, platform, options),
+		nativeDirTracked: false
 	});
+	if (untracked !== "regenerate") return untracked;
+	let tracked;
+	try {
+		tracked = (await gitAsync(root, [
+			"ls-files",
+			"--",
+			nativeDirName(platform)
+		], {
+			env: {
+				LC_ALL: "C",
+				LANGUAGE: "C"
+			},
+			signal
+		})).trim() !== "";
+	} catch (error) {
+		signal?.throwIfAborted();
+		tracked = unreadableGitTracksNativeDir(error);
+	}
+	return tracked ? "refuse" : "regenerate";
 }
 function recordPrebuild(root, platform, fingerprint) {
 	updateWorkspaceState(root, (state) => ({
@@ -307,11 +342,22 @@ function recordPrebuild(root, platform, fingerprint) {
 		}
 	}));
 }
+/**
+* @expo/cli 57 made `expo prebuild` delete existing native folders by default and added `--no-clean`
+* to keep them (expo/expo#47209); earlier CLIs keep them by default and reject `--no-clean`.
+*/
+function keepNativeDirArgs(root) {
+	return (expoSdkMajor(root) ?? 0) >= 57 ? ["--no-clean"] : [];
+}
+function staleNativeDirRemedy(platform) {
+	const dir = nativeDirName(platform);
+	return `Fix what the output above reports. Stim ran \`expo prebuild\` over the existing ${dir}/ without deleting it, which keeps what earlier config plugins wrote there. If ${dir}/ predates a removed config plugin or an Expo SDK upgrade, delete ${dir}/ and run again so Stim generates it fresh.`;
+}
 function staleNativeDirRefusal(platform) {
 	const dir = nativeDirName(platform);
 	return {
 		code: PREBUILD_ERROR,
-		message: `The fingerprint leaves ${dir}/ out of the cache key, and Stim cannot show that ${dir}/ was generated from the current app config. Git tracks files in it, or could not say whether it does, so Stim will not regenerate it with \`expo prebuild --clean\`.`,
+		message: `The fingerprint leaves ${dir}/ out of the cache key, and Stim cannot show that ${dir}/ was generated from the current app config. Git tracks files in it, or could not say whether it does, so Stim will not run \`expo prebuild\` over it.`,
 		remedy: `Stop excluding ${dir}/ from the fingerprint (check .fingerprintignore) so the cache key covers its files, or add ${dir}/ to .gitignore and untrack it so Stim regenerates it from the app config.`
 	};
 }
@@ -382,7 +428,7 @@ async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Da
 			"-p",
 			platform,
 			"--no-install",
-			...clean ? ["--clean"] : []
+			...clean ? ["--clean"] : dirExists ? keepNativeDirArgs(root) : []
 		], "expo");
 		child = spawnDeclared(ambientContext(), () => spawn(invocation.file, invocation.args, {
 			cwd: root,
@@ -428,6 +474,7 @@ async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Da
 			failed: true,
 			code: PREBUILD_ERROR,
 			reason: `\`expo prebuild -p ${platform}\` failed (${how}).`,
+			...dirExists && !clean ? { remedy: staleNativeDirRemedy(platform) } : {},
 			lastLines: tail.slice(),
 			durationMs
 		});
@@ -446,4 +493,4 @@ async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Da
 	};
 }
 //#endregion
-export { explainBuildMiss as a, skippedMissReason as c, staleNativeDirRefusal as i, recordPrebuild as n, fingerprintErrorMissReason as o, runPrebuild as r, predictBuildMiss as s, planPrebuild as t };
+export { staleNativeDirRefusal as a, predictBuildMiss as c, runPrebuild as i, skippedMissReason as l, planPrebuildAsync as n, explainBuildMiss as o, recordPrebuild as r, fingerprintErrorMissReason as s, planPrebuild as t };

package/dist/{project-BZNjmW_8.mjs → project-CTLNHCfE.mjs}

@@ -1,8 +1,8 @@
-import { p as process_identity_exports } from "./exec-_UbtCQcG.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
 import { c as supervisorPidFile, g as workspaceStateFile$1 } from "./paths-DQtTgsBf.mjs";
-import { H as deviceSlotKey, W as parseDeviceSlotKey, _ as loadConfig$1, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-CYcBF478.mjs";
-import { c as withWorkspaceStateLock, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-Cjuigeeu.mjs";
-import { Ft as repoRoot, K as resolveIosProjectDir, W as resolveAndroidLayout, at as webSettings, tt as settingValueAt } from "./settings-CsJDEXgK.mjs";
+import { U as parseDeviceSlotKey, V as deviceSlotKey, _ as loadConfig$1, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-DlrsduwG.mjs";
+import { c as withWorkspaceStateLock, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-U08dEzhG.mjs";
+import { K as resolveIosProjectDir, Mt as repoRoot, W as resolveAndroidLayout, at as webSettings, tt as settingValueAt } from "./settings-C7O8A6ZI.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { projectRootDirectories } from "@stim-cli/core/state";
@@ -308,8 +308,8 @@ const nativeAndroidIntegration = {
 			application: true,
 			platforms: () => ["android"],
 			validate: (operation) => operation === "android" ? null : void 0,
-			android: async () => (await import("./native-android-JACyjTZs.mjs")).nativeAndroidProject(root),
-			doctor: async () => (await import("./native-android-JACyjTZs.mjs")).nativeAndroidDoctor(root)
+			android: async () => (await import("./native-android-CdCSylTn.mjs")).nativeAndroidProject(root),
+			doctor: async () => (await import("./native-android-CdCSylTn.mjs")).nativeAndroidDoctor(root)
 		};
 	}
 };
@@ -737,8 +737,8 @@ const nativeXcodeProjectIntegration = {
 			application: problem === null,
 			platforms: () => problem ? [] : ["ios"],
 			validate: (operation) => operation === "ios" ? problem : void 0,
-			ios: async () => (await import("./native-xcode-ios-CXX39F7o.mjs")).nativeXcodeIosProject(root),
-			doctor: async () => (await import("./native-xcode-ios-CXX39F7o.mjs")).nativeXcodeDoctor(root)
+			ios: async () => (await import("./native-xcode-ios-_os2PlCD.mjs")).nativeXcodeIosProject(root),
+			doctor: async () => (await import("./native-xcode-ios-_os2PlCD.mjs")).nativeXcodeDoctor(root)
 		};
 	}
 };
@@ -943,7 +943,7 @@ function createProjectRegistry(integrations) {
 //#region src/integrations/projects.ts
 const expo = {
 	mode: MODE_EXPO,
-	loadDevServer: async () => (await import("./server-expo-C-90EhcG.mjs")).startExpoServer,
+	loadDevServer: async () => (await import("./server-expo-C-Buqvn_.mjs")).startExpoServer,
 	platforms(root) {
 		const appJson = readAppJson(root);
 		const config = appJson?.expo ?? appJson;
@@ -963,7 +963,7 @@ const expo = {
 };
 const reactNative = {
 	mode: MODE_BARE,
-	loadDevServer: async () => (await import("./server-bare-CxTrvDg8.mjs")).startBareServer,
+	loadDevServer: async () => (await import("./server-bare-CafzuyFB.mjs")).startBareServer,
 	platforms(root, { context, settings }) {
 		if (!declaresAppDependency(readPackageJson(root))) return [];
 		const platforms = [];
@@ -993,9 +993,9 @@ const projectRegistry = createProjectRegistry([
 				ownedRoots: problem === null ? [join(root, "ios"), join(root, "android")] : [],
 				platforms: (resolved) => nativeProjectIntegration(root).platforms(root, resolved),
 				validate: (operation) => operation === "ios" || operation === "android" || operation === "dev-server" ? problem : void 0,
-				ios: async (settings) => (await import("./react-native-ios-Bhq1rJeV.mjs")).reactNativeIosProject(root, settings),
-				android: async (resolved) => (await import("./react-native-android-DuzH0cn3.mjs")).reactNativeAndroidProject(root, resolved),
-				doctor: async () => (await import("./react-native-doctor-CQpuIMso.mjs")).reactNativeProjectDoctor(root)
+				ios: async (settings) => (await import("./react-native-ios-ChBF1MkB.mjs")).reactNativeIosProject(root, settings),
+				android: async (resolved) => (await import("./react-native-android-CFgUroxW.mjs")).reactNativeAndroidProject(root, resolved),
+				doctor: async () => (await import("./react-native-doctor-LTF-Xt8l.mjs")).reactNativeProjectDoctor(root)
 			};
 		}
 	},
@@ -1009,9 +1009,9 @@ const projectRegistry = createProjectRegistry([
 				application: true,
 				platforms: ({ settings }) => settingValueAt(settings, "macos.product") && settingValueAt(settings, "macos.infoPlist") ? ["macos"] : [],
 				validate: (operation) => operation === "macos" ? null : void 0,
-				macos: async () => (await import("./swiftpm-macos-p8WZbxKU.mjs")).swiftpmMacosProject(root),
+				macos: async () => (await import("./swiftpm-macos-r_WSKlXr.mjs")).swiftpmMacosProject(root),
 				doctor: async () => {
-					const { macosToolchain, macosToolchainAsync } = await import("./toolchain-DhKwp9iI.mjs");
+					const { macosToolchain, macosToolchainAsync } = await import("./toolchain-GVgnf8d1.mjs");
 					return {
 						inspect: () => [],
 						offloadTargets: ({ options: { host = process.platform, platform, operation } }) => host === "darwin" && platform === void 0 ? async () => [{
@@ -1031,7 +1031,7 @@ const projectRegistry = createProjectRegistry([
 				application: false,
 				platforms: ({ settings }) => webSettings(settings).url !== null ? ["web"] : [],
 				validate: (operation) => operation === "web" ? null : void 0,
-				web: async () => (await import("./browser-web-QQzVjz3O.mjs")).browserWebProject(root)
+				web: async () => (await import("./browser-web-CeEVlGug.mjs")).browserWebProject(root)
 			};
 		}
 	},