stim 1.14.0 → 1.16.0

package/dist/prebuild-D2fsca_Z.mjs

@@ -0,0 +1,213 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { r as detectIsExpo } from "./project-Du91Ilvc.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-B8-aJ1_5.mjs";
+import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
+import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-MC0rHlOC.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/engine/prebuild.ts
+const PREBUILD_ERROR = "STIM_PREBUILD_FAILED";
+const LAST_LINES = 20;
+function nativeDirName(platform) {
+	return platform === "android" ? "android" : "ios";
+}
+function nativeDir(root, platform) {
+	return join(root, nativeDirName(platform));
+}
+function nativeDirInFingerprint(sources, platform) {
+	const dir = nativeDirName(platform);
+	return sources.some((source) => source.type === "dir" && source.filePath === dir && source.hash != null);
+}
+/**
+* @expo/fingerprint leaves a native directory out of the hash when git ignores it (CNG), so the cache
+* key only covers that directory when this workspace's recorded prebuild ran on the same fingerprint.
+*/
+function prebuildAction({ isExpo, nativeDirExists, nativeDirFingerprinted, nativeDirTracked, generatedFrom, fingerprint }) {
+	if (!isExpo) return "none";
+	if (!nativeDirExists) return "generate";
+	if (nativeDirFingerprinted || generatedFrom === fingerprint) return "none";
+	return nativeDirTracked ? "refuse" : "regenerate";
+}
+function prebuildRecord(state) {
+	const record = state?.prebuild;
+	return record && typeof record === "object" ? record : {};
+}
+function gitTracksNativeDir(root, platform) {
+	try {
+		return getExecutor().runFile("git", [
+			"-C",
+			root,
+			"ls-files",
+			"--",
+			nativeDirName(platform)
+		], { env: {
+			LC_ALL: "C",
+			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));
+	}
+}
+function planPrebuild(root, platform, { isExpo, fingerprint, sources }) {
+	const nativeDirExists = existsSync(nativeDir(root, platform));
+	const fingerprinted = nativeDirInFingerprint(sources, platform);
+	const generatedFrom = prebuildRecord(readWorkspaceState(root))[platform];
+	return prebuildAction({
+		isExpo,
+		nativeDirExists,
+		nativeDirFingerprinted: fingerprinted,
+		nativeDirTracked: nativeDirExists && !fingerprinted && gitTracksNativeDir(root, platform),
+		generatedFrom: typeof generatedFrom === "string" ? generatedFrom : null,
+		fingerprint
+	});
+}
+function recordPrebuild(root, platform, fingerprint) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		prebuild: {
+			...prebuildRecord(state),
+			[platform]: fingerprint
+		}
+	}));
+}
+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\`.`,
+		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.`
+	};
+}
+function prebuildRefusal({ isExpo, platform, nativeDirExists }) {
+	if (nativeDirExists || isExpo) return null;
+	const dir = nativeDirName(platform);
+	return {
+		code: PREBUILD_ERROR,
+		message: `This project has no ${dir}/ directory and is not an Expo (CNG) project, so Stim cannot generate one.`,
+		remedy: `Check out or generate the native project (\`npx @react-native-community/cli init\` produced one originally), or add \`expo\` to the project so \`expo prebuild\` can create ${dir}/.`
+	};
+}
+function prebuildFailure(logWriter, result) {
+	logWriter?.write?.({
+		src: "build",
+		level: "error",
+		msg: result.reason || "Expo prebuild failed.",
+		event: "prebuild_failed"
+	});
+	return result;
+}
+async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Date.now, isExpo = null, clean = false } = {}) {
+	const dirExists = existsSync(nativeDir(root, platform));
+	const refusal = prebuildRefusal({
+		isExpo: isExpo === null ? detectIsExpo(root) : isExpo,
+		platform,
+		nativeDirExists: dirExists
+	});
+	if (refusal) return prebuildFailure(logWriter, {
+		failed: true,
+		code: refusal.code,
+		reason: refusal.message,
+		remedy: refusal.remedy,
+		error: refusal,
+		lastLines: []
+	});
+	const bin = expoBinPath(root);
+	if (!bin) {
+		const binRefusal = expoBinRefusal(root, "prebuild");
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: binRefusal.message,
+			remedy: binRefusal.remedy,
+			lastLines: []
+		});
+	}
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const startedAt = now();
+	const tail = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		tail.push(msg);
+		if (tail.length > LAST_LINES) tail.shift();
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "prebuild"
+		});
+	};
+	let child;
+	try {
+		child = spawnDeclared(() => spawn(bin, [
+			"prebuild",
+			"-p",
+			platform,
+			"--no-install",
+			...clean ? ["--clean"] : []
+		], {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				FORCE_COLOR: "0",
+				CI: "1"
+			}
+		}));
+	} catch (err) {
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `Could not run \`expo prebuild\`: ${err?.message || err}`,
+			lastLines: []
+		});
+	}
+	const outReader = createLineReader(push);
+	const errReader = createLineReader(push);
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => outReader.push(chunk));
+	child.stderr?.on("data", (chunk) => errReader.push(chunk));
+	const result = await waitForChild(child);
+	outReader.flush();
+	errReader.flush();
+	const durationMs = now() - startedAt;
+	if (result.error) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `Could not run \`expo prebuild\`: ${result.error?.message || result.error}`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	if (result.code !== 0) {
+		const how = result.signal ? `signal ${result.signal}` : `exit code ${result.code}`;
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `\`expo prebuild -p ${platform}\` failed (${how}).`,
+			lastLines: tail.slice(),
+			durationMs
+		});
+	}
+	if (!existsSync(nativeDir(root, platform))) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `\`expo prebuild -p ${platform}\` succeeded but did not create ${nativeDirName(platform)}/.`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	return {
+		ok: true,
+		durationMs,
+		nativeDir: nativeDir(root, platform)
+	};
+}
+//#endregion
+export { staleNativeDirRefusal as i, recordPrebuild as n, runPrebuild as r, planPrebuild as t };

package/dist/preview-DhVbvPAZ.mjs

@@ -0,0 +1,318 @@
+import { P as measuredDirectorySize } from "./config-D0DbpZtM.mjs";
+import { o as findProjectRoot$1 } from "./project-Du91Ilvc.mjs";
+import { X as discoverCaches, j as planCacheEmptying, o as readVolumeSpace, r as enforceBudget, s as resolveBudget } from "./budget-DjrURfQn.mjs";
+import { o as canonicalPath } from "./in-use-DvBw0Kxo.mjs";
+import { h as listBuildLocks } from "./device-lease-D-hLqx1b.mjs";
+import { n as listBuildSlots } from "./build-slots-rUk77xqh.mjs";
+import { j as readHostMemoryPressure } from "./ios-BaInn3sW.mjs";
+import { a as collectWorkspaceOutputs } from "./workspaces-BV4pdHFz.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
+import { buildWorkerRoot, loadConfig, readMaintenanceState, sharedCcache, sharedCompilationCache } from "@stim-cli/core/state";
+import { cpus, freemem, loadavg, totalmem } from "node:os";
+//#region src/maintenance/measure.ts
+function measurePressure(settings, previous, now) {
+	const config = loadConfig();
+	const level = readHostMemoryPressure();
+	const availableBytes = process.platform === "darwin" ? null : freemem();
+	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
+	const pressured = settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3));
+	return {
+		disk: readVolumeSpace([
+			configDir(),
+			...Object.keys(config?.projects ?? {}),
+			buildWorkerRoot(config)
+		]),
+		memory: {
+			level,
+			availableBytes,
+			pressured
+		},
+		warningSince
+	};
+}
+function sizeScanDeferred(settings) {
+	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
+}
+function cacheBlocked(entry, discovered = discoverCaches()) {
+	return planCacheEmptying([{
+		...entry,
+		note: "",
+		prune: "entries",
+		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
+	}], false)[0]?.machineGlobal ?? (entry.category === "compilation-cache" && [...listBuildLocks(), ...listBuildSlots()].some((item) => item.alive || item.unresolved) ? "a build lock or slot is live or unresolved" : void 0);
+}
+function measureSizes(now, failure) {
+	const sizes = [];
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		sizeTimeoutMs: 12e4
+	});
+	for (const entry of outputs.workspaces) {
+		if (entry.bytes === null) {
+			failure(entry.dir, entry.projectRoot ?? void 0);
+			continue;
+		}
+		sizes.push({
+			name: "workspace build outputs",
+			category: "workspace-outputs",
+			dir: entry.dir,
+			bytes: entry.bytes,
+			measuredAt: now,
+			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
+			idleDays: entry.idleDays,
+			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
+		});
+	}
+	const known = [
+		{
+			name: "shared build cache",
+			dir: buildCacheRoot(),
+			category: "build-cache"
+		},
+		{
+			name: "Metro transform caches",
+			dir: metroCacheRoot(),
+			category: "metro-cache"
+		},
+		{
+			name: "ccache",
+			dir: sharedCcache(),
+			category: "ccache"
+		},
+		{
+			name: "Swift compilation cache",
+			dir: sharedCompilationCache(),
+			category: "compilation-cache"
+		}
+	];
+	const discovered = discoverCaches();
+	for (const cache of discovered) {
+		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
+		if (cache.prune === "report-only") continue;
+		const dir = canonicalPath(cache.dir);
+		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
+		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
+		known.push({
+			name: cache.name,
+			dir: cache.dir,
+			category
+		});
+	}
+	for (const entry of known) {
+		if (!existsSync(entry.dir)) continue;
+		const bytes = measuredDirectorySize(entry.dir, { timeoutMs: 12e4 });
+		if (bytes === null) {
+			failure(entry.dir);
+			continue;
+		}
+		const blocked = cacheBlocked(entry, discovered);
+		sizes.push({
+			...entry,
+			bytes,
+			measuredAt: now,
+			...blocked ? { blocked } : {}
+		});
+	}
+	return sizes;
+}
+//#endregion
+//#region src/maintenance/plan.ts
+function plan({ pressure, sizes, settings, budget, diskSteps = [], protectedRoot, scoped = false, projects = [] }) {
+	const actions = [];
+	const blocked = [];
+	const skips = [];
+	const add = (action) => {
+		if (!actions.some((entry) => entry.kind === action.kind && entry.target === action.target)) actions.push(action);
+	};
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const low = pressure?.disk.filter((disk) => disk.freeMb < floor) ?? [];
+	const reason = low.map((disk) => `free disk ${(disk.freeMb / 1024).toFixed(1)}G on ${disk.volume} under the ${(floor / 1024).toFixed(1)}G floor`).join("; ");
+	const kinds = {
+		"idle-devices": "would-shutdown-device",
+		"idle-dev-servers": "would-stop-workspace",
+		"workspace-outputs": "would-clear-outputs",
+		"stale-cache-entries": "would-trim-cache"
+	};
+	if (low.length) {
+		for (const step of diskSteps) {
+			if (scoped && step.step === "idle-devices") continue;
+			for (const target of step.targets) {
+				const workspace = projects.find((root) => root === target || target.endsWith(` in ${root}`)) ?? (step.step === "idle-dev-servers" || step.step === "workspace-outputs" ? target : void 0);
+				if (workspace === protectedRoot || target === protectedRoot) continue;
+				const size = workspace && step.step !== "idle-devices" ? sizes.find((entry) => entry.workspace === workspace && entry.category === "workspace-outputs") : void 0;
+				add({
+					kind: kinds[step.step],
+					target,
+					bytes: step.step === "workspace-outputs" ? size?.bytes ?? 0 : 0,
+					reason: `${size?.idleDays == null ? "" : `idle ${size.idleDays} days, `}${reason}`,
+					...workspace ? { workspace } : {}
+				});
+			}
+			if (step.failures) blocked.push(`Could not plan ${step.step}: ${step.failures} failures`);
+		}
+		if (actions.length === 0) blocked.push(`${reason}; no reclaimable disk targets`);
+	}
+	const caps = [
+		[
+			"workspace-outputs",
+			settings.workspaceOutputsMaxGb,
+			"would-clear-outputs"
+		],
+		[
+			"build-cache",
+			settings.buildCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"metro-cache",
+			settings.metroCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"compilation-cache",
+			settings.swiftCompilationCacheMaxGb,
+			"would-empty-cache"
+		]
+	];
+	for (const [category, capGb, kind] of caps) {
+		const entries = sizes.filter((size) => size.category === category);
+		const total = entries.reduce((sum, size) => sum + size.bytes, 0);
+		const cap = capGb * 1024 ** 3;
+		if (cap === 0 || total <= cap) continue;
+		let remaining = total;
+		const targetBytes = cap * settings.capTargetPercent / 100;
+		const why = `${category} ${(total / 1024 ** 3).toFixed(1)}G over the ${capGb}G cap; target ${(targetBytes / 1024 ** 3).toFixed(1)}G`;
+		for (const size of entries.toSorted((a, b) => (b.idleDays ?? 0) - (a.idleDays ?? 0))) {
+			if (remaining <= targetBytes) break;
+			const kept = size.workspace === protectedRoot ? "the triggering workspace is protected" : size.blocked;
+			if (kept) {
+				skips.push({
+					target: size.dir,
+					reason: kept,
+					...size.workspace ? { workspace: size.workspace } : {}
+				});
+				continue;
+			}
+			const bytes = kind === "would-trim-cache" ? Math.min(size.bytes, remaining - targetBytes) : size.bytes;
+			add({
+				kind,
+				target: size.workspace ?? size.dir,
+				bytes,
+				reason: `${!size.workspace || size.idleDays == null ? "" : `idle ${size.idleDays} days, `}${why}`,
+				...size.workspace ? { workspace: size.workspace } : {}
+			});
+			remaining -= bytes;
+		}
+		if (remaining > targetBytes) blocked.push(`${why}; eligible targets cannot reach the target`);
+	}
+	if (pressure?.memory.pressured) skips.push({
+		target: "memory",
+		reason: "memory pressure observed; stopping helpers and idle workspaces is not active in report-only mode"
+	});
+	return {
+		actions,
+		blocked,
+		skips
+	};
+}
+//#endregion
+//#region src/maintenance/preview.ts
+function triggeringRoot() {
+	return canonicalPath(findProjectRoot$1(process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
+}
+async function plannedMaintenance(pressure, sizes, settings, { devices = true } = {}) {
+	const resolved = resolveBudget();
+	if (resolved.error) throw new Error(resolved.error);
+	const budget = {
+		...resolved.budget,
+		maxCommittedMemoryMb: 0,
+		maxLiveWorkspaces: 0
+	};
+	const root = triggeringRoot();
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const low = pressure?.disk.some((disk) => disk.freeMb < floor);
+	const outcome = low ? await enforceBudget({
+		root,
+		note: () => {},
+		dryRun: true,
+		budget
+	}, { volumes: () => pressure.disk }) : null;
+	if (outcome && outcome.status !== "ok") throw new Error(outcome.refusal.message);
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now: Date.now(),
+		measure: false
+	});
+	const result = plan({
+		pressure,
+		sizes: sizes.map((size) => {
+			if (size.category === "compilation-cache") return {
+				...size,
+				blocked: cacheBlocked(size)
+			};
+			if (!size.workspace) return size;
+			const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
+			return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
+		}),
+		settings,
+		budget,
+		diskSteps: outcome?.status === "ok" ? outcome.reclaimed.filter((step) => devices || step.step !== "idle-devices") : [],
+		protectedRoot: root,
+		scoped: Boolean(process.env.STIM_HOME),
+		projects: Object.keys(loadConfig()?.projects ?? {}).map(canonicalPath)
+	});
+	if (low) result.skips.push(...outputs.workspaces.filter((entry) => !entry.willClear && entry.keptReason).map((entry) => ({
+		target: entry.dir,
+		reason: entry.keptReason,
+		workspace: entry.projectRoot ?? void 0
+	})));
+	return result;
+}
+async function previewMaintenance({ devices = true } = {}) {
+	let settings;
+	try {
+		settings = resolveMaintenanceSettings();
+		const state = readMaintenanceState();
+		if (settings.invalid && settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			invalid: settings.invalid,
+			note: settings.invalid
+		};
+		if (settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			note: "maintenance.mode is off"
+		};
+		const pressure = measurePressure(settings, state?.pressure ?? null, Date.now());
+		return {
+			...await plannedMaintenance(pressure, state?.sizes ?? [], settings, { devices }),
+			mode: settings.mode,
+			...settings.invalid ? { invalid: settings.invalid } : {},
+			pressure,
+			note: settings.invalid ?? (state === null ? "no pass has run yet; sizes have not been measured" : null)
+		};
+	} catch (error) {
+		return {
+			mode: settings?.mode ?? "off",
+			...settings?.invalid ? { invalid: settings.invalid } : {},
+			pressure: null,
+			actions: [],
+			blocked: [String(error)],
+			skips: [],
+			note: "maintenance preview failed"
+		};
+	}
+}
+//#endregion
+export { sizeScanDeferred as a, measureSizes as i, previewMaintenance as n, measurePressure as r, plannedMaintenance as t };

package/dist/process-identity-BmRm1qV0.mjs

@@ -0,0 +1,12 @@
+import { n as __exportAll, r as __reExport } from "./rolldown-runtime-BsOwBuO_.mjs";
+//#region src/ownership-claim.ts
+var ownership_claim_exports = /* @__PURE__ */ __exportAll({});
+import * as import__stim_cli_core_ownership_claim from "@stim-cli/core/ownership-claim";
+__reExport(ownership_claim_exports, import__stim_cli_core_ownership_claim);
+//#endregion
+//#region src/process-identity.ts
+var process_identity_exports = /* @__PURE__ */ __exportAll({});
+import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
+__reExport(process_identity_exports, import__stim_cli_core_process_identity);
+//#endregion
+export { ownership_claim_exports as n, process_identity_exports as t };

package/dist/{project-CWlvEaeN.mjs → project-Du91Ilvc.mjs}

@@ -1,7 +1,8 @@
-import { _ as loadConfig, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-lvc7d3C2.mjs";
-import { y as repoRoot } from "./worktree-BVrHsYZG.mjs";
-import { existsSync, readFileSync, realpathSync } from "fs";
+import { _ as loadConfig$1, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-D0DbpZtM.mjs";
+import { U as webSettings, gt as repoRoot, z as settingValueAt } from "./settings-oTSkkNrM.mjs";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { basename, dirname, join, resolve } from "path";
+import { findProjectRoot, findProjectRoot as findProjectRoot$1 } from "@stim-cli/core/state";
 //#region src/workspace/project.ts
 /**
 * The realpath of `name`'s package.json in the nearest `node_modules` at or above `projectRoot`.
@@ -37,23 +38,13 @@ const NO_PROJECT_REFUSAL = {
 	message: "Not in a React Native project (no package.json found).",
 	remedy: "Run this from the app directory -- the one holding package.json."
 };
-function findProjectRoot(startDir) {
-	let dir;
-	try {
-		dir = realpathSync(resolve(startDir));
-	} catch {
-		dir = resolve(startDir);
-	}
-	while (true) {
-		if (existsSync(join(dir, "package.json"))) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
 function findServerWorkspace(startDir) {
 	const nearest = findProjectRoot(startDir);
 	if (!nearest) return null;
+	if (existsSync(join(nearest, "Package.swift"))) return {
+		root: nearest,
+		from: null
+	};
 	if (appProjectProblem(nearest)?.kind !== "not-an-app") return {
 		root: nearest,
 		from: null
@@ -68,7 +59,7 @@ function findServerWorkspace(startDir) {
 		from: null
 	};
 	const worktree = expandedRealpath(top);
-	const apps = Object.keys(loadConfig()?.projects ?? {}).filter((path) => {
+	const apps = Object.keys(loadConfig$1()?.projects ?? {}).filter((path) => {
 		if (path === nearest || !isPathPrefix(worktree, expandedRealpath(path)) || appProjectProblem(path) !== null) return false;
 		const owner = repoRoot(path);
 		return owner !== null && expandedRealpath(owner) === worktree;
@@ -162,6 +153,70 @@ function detectIsExpo(projectRoot) {
 	if (podfileUsesExpoModules(projectRoot)) return true;
 	return false;
 }
+function detectPlatforms(root, settings) {
+	const platforms = /* @__PURE__ */ new Set();
+	const product = settingValueAt(settings, "macos.product");
+	const infoPlist = settingValueAt(settings, "macos.infoPlist");
+	if (existsSync(join(root, "Package.swift")) && product && infoPlist) platforms.add("macos");
+	if (webSettings(settings).url !== null) platforms.add("web");
+	const pkg = readPackageJson(root);
+	const deps = {
+		...pkg?.dependencies,
+		...pkg?.devDependencies
+	};
+	if (detectIsExpo(root)) {
+		const appJson = readAppJson(root);
+		const config = appJson?.expo ?? appJson;
+		const text = readAppConfigText(root);
+		const explicit = (text ? literalPlatforms(text) : null) ?? config?.platforms;
+		if (Array.isArray(explicit)) {
+			for (const platform of explicit) if (platform === "ios" || platform === "android" || platform === "web") platforms.add(platform);
+		} else {
+			platforms.add("ios");
+			platforms.add("android");
+			if ("react-native-web" in deps || isPackageResolvable(root, "react-native-web")) platforms.add("web");
+		}
+	} else if (declaresAppDependency(pkg)) {
+		let ios = [];
+		try {
+			ios = readdirSync(join(root, "ios"));
+		} catch {}
+		if (ios.some((name) => name.endsWith(".xcodeproj") || name.endsWith(".xcworkspace"))) platforms.add("ios");
+		if ([
+			"build.gradle",
+			"build.gradle.kts",
+			"settings.gradle",
+			"settings.gradle.kts"
+		].some((name) => existsSync(join(root, "android", name)))) platforms.add("android");
+	}
+	return [
+		"ios",
+		"android",
+		"macos",
+		"web"
+	].filter((platform) => platforms.has(platform));
+}
+function literalPlatforms(text) {
+	const tokens = text.match(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|[A-Za-z_$][\w$]*|[^\s]/g)?.filter((token) => !token.startsWith("//") && !token.startsWith("/*")) ?? [];
+	let open = 0;
+	const index = tokens.findIndex((token, i) => {
+		if (token === "[") open++;
+		else if (token === "]") open--;
+		return open === 0 && (token === "platforms" || token === "\"platforms\"" || token === "'platforms'") && tokens[i + 1] === ":";
+	});
+	if (index < 0 || tokens[index + 2] !== "[") return null;
+	const platforms = [];
+	let i = index + 3;
+	while (tokens[i] !== "]") {
+		const value = tokens[i]?.match(/^(['"])([a-z]+)\1$/)?.[2];
+		if (value === void 0) return null;
+		platforms.push(value);
+		i++;
+		if (tokens[i] === ",") i++;
+		else if (tokens[i] !== "]") return null;
+	}
+	return tokens[i + 1] === "," || tokens[i + 1] === "}" ? platforms : null;
+}
 function looksLikeExpoConfig(appJson) {
 	if (!appJson || typeof appJson !== "object" || Array.isArray(appJson)) return false;
 	if (appJson.expo) return true;
@@ -213,4 +268,4 @@ function readAppConfigText(projectRoot) {
 	return null;
 }
 //#endregion
-export { findProjectRoot as a, ownedDeviceLabel as c, readAppJson as d, resolvePackageJson as f, findCommandWorkspace as i, projectShortcut as l, appProjectProblem as n, findServerWorkspace as o, detectIsExpo as r, isPackageResolvable as s, NO_PROJECT_REFUSAL as t, readAppConfigText as u };
+export { findCommandWorkspace as a, isPackageResolvable as c, readAppConfigText as d, readAppJson as f, detectPlatforms as i, ownedDeviceLabel as l, appProjectProblem as n, findProjectRoot$1 as o, resolvePackageJson as p, detectIsExpo as r, findServerWorkspace as s, NO_PROJECT_REFUSAL as t, projectShortcut as u };