stim 1.19.0 → 1.20.0

package/dist/project-B8_duAzW.mjs

@@ -0,0 +1,1067 @@
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { B as parseDeviceSlotKey, R as deviceSlotKey, _ as loadConfig$1, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-D0LhTY3S.mjs";
+import { $ as settingValueAt, Et as repoRoot, G as resolveIosProjectDir, U as resolveAndroidLayout, rt as webSettings } from "./settings-Bbztm4oV.mjs";
+import { E as workspaceStateFile, a as updateWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as supervisorPidFile } from "./workspace-state-CSIFuuDa.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename as basename$1, dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
+import { projectRootDirectories } from "@stim-cli/core/state";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, realpathSync as realpathSync$1 } from "fs";
+import { DOMParser } from "@xmldom/xmldom";
+import pbxParser from "xcode/lib/parser/pbxproj.js";
+//#region src/supervisor/state.ts
+const MODE_BARE = "bare-inproc";
+const MODE_EXPO = "expo-child";
+const MODE_COMMAND = "command-child";
+function workspaceDevServerMode(root, isExpo) {
+	const mode = readWorkspaceState$1(root)?.supervisor?.mode;
+	return typeof mode === "string" ? mode : isExpo ? MODE_EXPO : MODE_BARE;
+}
+function readMetroTunnel(root) {
+	const record = readWorkspaceState$1(root)?.metroTunnel;
+	if (!record || typeof record !== "object") return null;
+	const kind = record.kind;
+	const url = record.url;
+	if (typeof url !== "string" || url.length === 0) return null;
+	if (kind === "expo") return {
+		kind: "expo",
+		url
+	};
+	if (kind === "managed") {
+		const provider = record.provider;
+		const pid = record.pid;
+		const port = record.port;
+		const startedAt = record.startedAt;
+		const processToken = record.processToken;
+		const logFile = record.logFile;
+		if (provider !== "ngrok" && provider !== "cloudflared" && provider !== "tailscale" || typeof pid !== "number" || typeof port !== "number") return null;
+		return {
+			kind: "managed",
+			provider,
+			pid,
+			url,
+			port,
+			startedAt: typeof startedAt === "string" ? startedAt : "",
+			processToken: typeof processToken === "string" && processToken.length > 0 ? processToken : null,
+			...typeof logFile === "string" && logFile.length > 0 ? { logFile } : {}
+		};
+	}
+	return null;
+}
+function parseWorkspaceLaunchRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.appId !== "string" || record.appId.length === 0) return null;
+	if (typeof record.deviceId !== "string" || record.deviceId.length === 0) return null;
+	if (record.metroPort !== null && typeof record.metroPort !== "number") return null;
+	if (typeof record.release !== "boolean") return null;
+	if (record.runtime !== void 0 && (record.runtime !== "process" || record.metroPort !== null)) return null;
+	if (typeof record.launchedAt !== "string") return null;
+	return record;
+}
+function readWorkspaceLaunches(root) {
+	const launches = readWorkspaceState$1(root)?.launches;
+	if (!launches || typeof launches !== "object" || Array.isArray(launches)) return {};
+	const records = {};
+	for (const [key, value] of Object.entries(launches)) {
+		const record = parseWorkspaceLaunchRecord(value);
+		if (parseDeviceSlotKey(key) && record) records[key] = record;
+	}
+	return records;
+}
+function writeWorkspaceLaunch(root, platform, record, slot = "default") {
+	updateWorkspaceState(root, (state) => {
+		const launches = state.launches && typeof state.launches === "object" ? state.launches : {};
+		return {
+			...state,
+			launches: {
+				...launches,
+				[deviceSlotKey(platform, slot)]: record
+			}
+		};
+	});
+}
+function clearWorkspaceLaunches(root, slot) {
+	updateWorkspaceState(root, (state) => {
+		if (!state.launches || typeof state.launches !== "object") return state;
+		const launches = { ...state.launches };
+		delete launches[deviceSlotKey("ios", slot)];
+		delete launches[deviceSlotKey("android", slot)];
+		return {
+			...state,
+			launches
+		};
+	});
+}
+function readRemoteSession(root) {
+	const record = readWorkspaceState$1(root)?.remoteDevice;
+	if (!record || typeof record !== "object") return null;
+	const id = record.sessionId;
+	if (typeof id !== "string" || id.length === 0) return null;
+	const platform = record.platform;
+	const startedAt = record.startedAt;
+	const webPreviewUrl = record.webPreviewUrl;
+	const deviceType = record.deviceType;
+	return {
+		platform: platform === "ios" || platform === "android" ? platform : null,
+		sessionId: id,
+		startedAt: typeof startedAt === "string" ? startedAt : null,
+		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null,
+		deviceType: typeof deviceType === "string" && deviceType.length > 0 ? deviceType : null
+	};
+}
+function readRemoteSessionId(root) {
+	return readRemoteSession(root)?.sessionId ?? null;
+}
+function clearRemoteSession(root, expectedSessionId) {
+	clearWorkspaceStateKey(root, "remoteDevice", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		return value.sessionId === expectedSessionId;
+	});
+}
+function clearWorkspaceSupervisor(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		const current = readWorkspaceState$1(root)?.supervisor;
+		if (current && expected !== void 0 && !(0, process_identity_exports.sameProcessRecord)(current, expected)) return false;
+		clearWorkspaceStateKey(root, "supervisor", () => true);
+		clearExpoMetroTunnel(root);
+		if (expected === void 0 || readPidFile(root) === expected?.pid) rmSync(supervisorPidFile(root), { force: true });
+		return true;
+	});
+}
+function clearExpoMetroTunnel(root) {
+	clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		return typeof value === "object" && value !== null && value.kind === "expo";
+	});
+}
+function clearManagedMetroTunnel(root, expected) {
+	if (!existsSync(workspaceStateFile(root))) return true;
+	return clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		const record = value;
+		return record.kind === "managed" && record.provider === expected.provider && record.pid === expected.pid && record.url === expected.url && record.port === expected.port && record.startedAt === expected.startedAt && (record.processToken ?? null) === (expected.processToken ?? null) && (record.logFile ?? null) === (expected.logFile ?? null);
+	});
+}
+function writePidFile(root, pid) {
+	const file = supervisorPidFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${pid}\n`);
+	return file;
+}
+function readPidFile(root) {
+	try {
+		const pid = parseInt(readFileSync(supervisorPidFile(root), "utf-8").trim(), 10);
+		return Number.isFinite(pid) ? pid : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/workspace/project-files.ts
+/**
+* The realpath of `name`'s package.json in the nearest `node_modules` at or above `projectRoot`.
+* Unlike `require.resolve`, it ignores `NODE_PATH`, which pnpm's bin shims point at the workspace's
+* hidden hoist directory holding every member's dependencies.
+*/
+function resolvePackageJson(projectRoot, name) {
+	for (let dir = resolve$1(projectRoot);; dir = dirname$1(dir)) {
+		const candidate = join$1(dir, "node_modules", name, "package.json");
+		if (existsSync$1(candidate)) return realpathSync$1(candidate);
+		if (dirname$1(dir) === dir) return null;
+	}
+}
+function isPackageResolvable(projectRoot, name) {
+	return resolvePackageJson(projectRoot, name) !== null;
+}
+function loadPackageJson(projectRoot) {
+	const p = join$1(projectRoot, "package.json");
+	if (!existsSync$1(p)) return {
+		pkg: null,
+		parseError: null
+	};
+	try {
+		return {
+			pkg: JSON.parse(readFileSync$1(p, "utf-8")),
+			parseError: null
+		};
+	} catch (error) {
+		return {
+			pkg: null,
+			parseError: error?.message || String(error)
+		};
+	}
+}
+function readPackageJson(projectRoot) {
+	return loadPackageJson(projectRoot).pkg;
+}
+const APP_DEPENDENCIES = ["react-native", "expo"];
+function declaresAppDependency(pkg) {
+	if (!pkg || typeof pkg !== "object") return false;
+	const { dependencies, devDependencies, peerDependencies } = pkg;
+	const deps = {
+		...dependencies,
+		...devDependencies,
+		...peerDependencies
+	};
+	return APP_DEPENDENCIES.some((name) => name in deps);
+}
+function appProjectProblem(projectRoot, { pkg, parseError } = loadPackageJson(projectRoot)) {
+	const file = join$1(projectRoot, "package.json");
+	if (parseError) return {
+		kind: "unreadable",
+		message: `${file} is not valid JSON (${parseError}), so Stim cannot tell whether this is a React Native or Expo app.`,
+		remedy: `Fix the JSON in ${file} -- an unfinished edit or a merge conflict leaves it unparseable -- then run the command again.`
+	};
+	if (declaresAppDependency(pkg)) return null;
+	return {
+		kind: "not-an-app",
+		message: `${file} depends on neither react-native nor expo, so this is not a React Native or Expo app.`,
+		remedy: "Run this from the app directory -- the one whose package.json depends on react-native or expo -- or from that directory inside a worktree."
+	};
+}
+function detectIsExpo(projectRoot) {
+	const pkg = readPackageJson(projectRoot);
+	const iosScript = pkg?.scripts?.ios;
+	if (typeof iosScript === "string") {
+		if (/\bexpo\s+run:ios\b/.test(iosScript)) return true;
+		if (/\breact-native\s+run-ios\b/.test(iosScript)) return false;
+	}
+	if (!pkg) return false;
+	const hasExpoDep = "expo" in {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const resolvable = () => isPackageResolvable(projectRoot, "expo");
+	if (!hasExpoDep && !resolvable()) return false;
+	const appJson = readAppJson(projectRoot);
+	if (appJson?.expo) return true;
+	const text = readAppConfigText(projectRoot);
+	if (text && /\b(?:from\s+['"]expo['"]|expo\/config|ExpoConfig)\b/.test(text)) return true;
+	if (hasExpoDep && resolvable()) return true;
+	if (looksLikeExpoConfig(appJson)) return true;
+	if (podfileUsesExpoModules(projectRoot)) return true;
+	return false;
+}
+function detectTutorial(appJson) {
+	const extra = appJson?.expo?.extra;
+	const version = typeof extra === "object" && extra !== null ? extra.stimTutorial : null;
+	return typeof version === "number" && Number.isInteger(version) && version > 0 ? { version } : void 0;
+}
+function looksLikeExpoConfig(appJson) {
+	if (!appJson || typeof appJson !== "object" || Array.isArray(appJson)) return false;
+	if (appJson.expo) return true;
+	if ([
+		"slug",
+		"plugins",
+		"sdkVersion",
+		"experiments",
+		"runtimeVersion",
+		"updates",
+		"buildCacheProvider",
+		"assetBundlePatterns",
+		"splash",
+		"orientation",
+		"userInterfaceStyle"
+	].some((key) => appJson[key] !== void 0)) return true;
+	return Boolean(appJson.extra && typeof appJson.extra === "object" && appJson.extra.eas);
+}
+function podfileUsesExpoModules(projectRoot) {
+	const p = join$1(projectRoot, "ios", "Podfile");
+	if (!existsSync$1(p)) return false;
+	try {
+		return /^[^#\n]*use_expo_modules!/m.test(readFileSync$1(p, "utf-8"));
+	} catch {
+		return false;
+	}
+}
+function readAppJson(projectRoot) {
+	const p = join$1(projectRoot, "app.json");
+	if (!existsSync$1(p)) return null;
+	try {
+		return JSON.parse(readFileSync$1(p, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function readAppConfigText(projectRoot) {
+	for (const name of [
+		"app.config.js",
+		"app.config.ts",
+		"app.config.cjs",
+		"app.config.mjs"
+	]) {
+		const p = join$1(projectRoot, name);
+		if (existsSync$1(p)) try {
+			return readFileSync$1(p, "utf-8");
+		} catch {}
+	}
+	return null;
+}
+//#endregion
+//#region src/integrations/native-android-discovery.ts
+const nativeAndroidIntegration = {
+	id: "native-android",
+	inspect(root) {
+		if (declaresAppDependency(readPackageJson(root)) || !["settings.gradle", "settings.gradle.kts"].some((name) => existsSync(join(root, name))) || !["gradlew", "gradlew.bat"].some((name) => existsSync(join(root, name)))) return null;
+		return {
+			root: "candidate",
+			application: true,
+			platforms: () => ["android"],
+			validate: (operation) => operation === "android" ? null : void 0,
+			android: async () => (await import("./native-android-lHzaew7r.mjs")).nativeAndroidProject(root),
+			doctor: async () => (await import("./native-android-lHzaew7r.mjs")).nativeAndroidDoctor(root)
+		};
+	}
+};
+//#endregion
+//#region src/integrations/native-xcode-syntax.ts
+function parseNativeXcodeSyntax(source) {
+	let normalized = "";
+	for (let at = 0; at < source.length;) {
+		const start = at;
+		if (source[at] === "\"") {
+			at++;
+			while (at < source.length) if (source[at] === "\\") at += 2;
+			else if (source[at++] === "\"") break;
+		} else if (source.startsWith("/*", at)) {
+			const end = source.indexOf("*/", at + 2);
+			at = end < 0 ? source.length : end + 2;
+		} else if (source.startsWith("//", at)) {
+			const end = source.indexOf("\n", at + 2);
+			at = end < 0 ? source.length : end + 1;
+		} else if (source.startsWith("$(", at)) {
+			at += 2;
+			let depth = 1;
+			while (at < source.length && depth > 0) {
+				if (source[at] === "(") depth++;
+				else if (source[at] === ")") depth--;
+				at++;
+			}
+		} else {
+			if (source[at] === ")") normalized += "\n";
+			at++;
+		}
+		normalized += source.slice(start, at);
+	}
+	return pbxParser.parse(normalized);
+}
+//#endregion
+//#region src/integrations/native-xcode-project.ts
+var NativeXcodeError = class extends Error {
+	code = "STIM_BAD_ARG";
+	remedy;
+	constructor(message, remedy) {
+		super(message);
+		this.remedy = remedy;
+	}
+};
+function pbxString(value) {
+	if (typeof value === "number") return String(value);
+	if (typeof value !== "string") return null;
+	if (!value.startsWith("\"")) return value.trim();
+	try {
+		return JSON.parse(value);
+	} catch {
+		throw new NativeXcodeError("An Xcode project contains an unreadable quoted value.", "Open the project in Xcode and repair its project file.");
+	}
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function pbxReferences(value) {
+	return Array.isArray(value) ? value.flatMap((entry) => {
+		const name = pbxString(object(entry)?.value ?? entry);
+		return name === null ? [] : [name];
+	}) : [];
+}
+function readNativeXcodeModel(path) {
+	const project = object(object(parseNativeXcodeSyntax(readFileSync(join(path, "project.pbxproj"), "utf8")))?.project);
+	const objects = /* @__PURE__ */ new Map();
+	const collect = (value) => {
+		for (const [id, entry] of Object.entries(object(value) ?? {})) {
+			const record = object(entry);
+			if (!record) continue;
+			if (typeof record.isa === "string") objects.set(id, record);
+			else collect(record);
+		}
+	};
+	collect(project?.objects);
+	const root = objects.get(pbxString(project?.rootObject) ?? "");
+	if (!root || root.isa !== "PBXProject") throw new NativeXcodeError(`No Xcode project object in ${path}.`, "Repair the project in Xcode.");
+	return {
+		path: realpathSync(path),
+		directory: realpathSync(dirname(path)),
+		project: root,
+		objects
+	};
+}
+function xml(path) {
+	const document = new DOMParser({ onError: (_level, message) => {
+		throw new Error(message);
+	} }).parseFromString(readFileSync(path, "utf8"), "application/xml");
+	if (document.doctype || !document.documentElement) throw new Error(`Unsupported XML document at ${path}.`);
+	return document.documentElement;
+}
+function workspaceProjects(path) {
+	const projects = [];
+	const walk = (node, base) => {
+		const location = node.getAttribute("location");
+		let here = base;
+		if (location) {
+			const colon = location.indexOf(":");
+			const kind = location.slice(0, colon);
+			const value = location.slice(colon + 1);
+			if (kind === "group") here = resolve(base, value);
+			else if (kind === "container" || kind === "self") here = resolve(dirname(path), value);
+			else if (kind === "absolute" && isAbsolute(value)) here = value;
+			else throw new Error(`Unsupported workspace reference ${location}.`);
+		}
+		if (node.tagName === "FileRef") {
+			if (!here.endsWith(".xcodeproj")) throw new Error(`Workspace reference ${here} is not an Xcode project.`);
+			projects.push(here);
+		}
+		for (let i = 0; i < node.childNodes.length; i++) {
+			const child = node.childNodes.item(i);
+			if (child?.nodeType === 1) walk(child, here);
+		}
+	};
+	walk(xml(join(path, "contents.xcworkspacedata")), dirname(path));
+	return [...new Set(projects)];
+}
+function configurations(project, owner) {
+	return pbxReferences(project.objects.get(pbxString(owner.buildConfigurationList) ?? "")?.buildConfigurations).flatMap((id) => {
+		const configuration = project.objects.get(id);
+		return configuration ? [configuration] : [];
+	});
+}
+function buildSettings(project, target, configuration) {
+	const settings = (owner) => object(configurations(project, owner).find((candidate) => pbxString(candidate.name) === configuration)?.buildSettings) ?? {};
+	return {
+		...settings(project.project),
+		...settings(target)
+	};
+}
+const PLATFORM_KEYS = [
+	"SDKROOT",
+	"SUPPORTED_PLATFORMS",
+	"IPHONEOS_DEPLOYMENT_TARGET"
+];
+const UNKNOWN_PLATFORM_SETTINGS = { unresolved: true };
+function configurationPath(project, reference) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (id, base) => {
+		if (seen.has(id)) return null;
+		seen.add(id);
+		const entry = project.objects.get(id);
+		if (!entry) return null;
+		const value = pbxString(entry.path) ?? "";
+		if (value.includes("$")) return null;
+		const tree = pbxString(entry.sourceTree) ?? "<group>";
+		const path = tree === "<group>" ? resolve(base, value) : tree === "SOURCE_ROOT" ? resolve(project.directory, value) : tree === "<absolute>" && isAbsolute(value) ? value : null;
+		if (path === null || id === reference) return path;
+		for (const child of pbxReferences(entry.children)) {
+			const found = visit(child, path);
+			if (found !== null) return found;
+		}
+		return null;
+	};
+	return visit(pbxString(project.project.mainGroup) ?? "", project.directory);
+}
+function configurationPlatforms(path, active = /* @__PURE__ */ new Set()) {
+	try {
+		path = realpathSync(path);
+	} catch {
+		return { ...UNKNOWN_PLATFORM_SETTINGS };
+	}
+	if (active.has(path)) return { ...UNKNOWN_PLATFORM_SETTINGS };
+	active.add(path);
+	const settings = {};
+	try {
+		for (const raw of readFileSync(path, "utf8").split(/\r\n?|\n|\u2028|\u2029/)) {
+			const line = raw.replace(/\/\/.*$/, "").trim();
+			if (!line) continue;
+			const include = line.match(/^#include(\?)?\s+"([^"$]+)"\s*$/);
+			if (include) {
+				const child = resolve(dirname(path), include[2]);
+				if (!include[1] || existsSync(child)) Object.assign(settings, configurationPlatforms(child, active));
+				continue;
+			}
+			const setting = line.match(/^([A-Za-z_][A-Za-z_0-9]*)(\[[^\]]+\])*\s*=\s*(.*)$/);
+			if (!setting || line.endsWith("\\") || /\/\*|\*\//.test(line)) {
+				Object.assign(settings, UNKNOWN_PLATFORM_SETTINGS);
+				continue;
+			}
+			const key = PLATFORM_KEYS.find((candidate) => candidate === setting[1]);
+			if (key) {
+				if (setting[2]) settings.unresolved = true;
+				const value = pbxString(setting[3]);
+				settings[key] = value === null || /[$'\\]/.test(value) ? null : value;
+			}
+		}
+		return settings;
+	} catch {
+		return { ...UNKNOWN_PLATFORM_SETTINGS };
+	} finally {
+		active.delete(path);
+	}
+}
+function applicationPlatform(project, target, configuration) {
+	const settings = {};
+	for (const owner of [project.project, target]) {
+		const config = configurations(project, owner).find((candidate) => pbxString(candidate.name) === configuration);
+		const base = pbxString(config?.baseConfigurationReference);
+		if (base) {
+			const path = configurationPath(project, base);
+			Object.assign(settings, path ? configurationPlatforms(path) : UNKNOWN_PLATFORM_SETTINGS);
+		}
+		for (const [rawKey, value] of Object.entries(object(config?.buildSettings) ?? {})) {
+			if (rawKey.endsWith("_comment")) continue;
+			const key = pbxString(rawKey);
+			const name = PLATFORM_KEYS.find((candidate) => key === candidate || key.startsWith(`${candidate}[`));
+			if (!name) continue;
+			const text = Array.isArray(value) ? pbxReferences(value).join(" ") : pbxString(value);
+			if (key !== name) settings.unresolved = true;
+			settings[name] = text?.includes("$") ? null : text;
+		}
+	}
+	if (settings.unresolved || Object.values(settings).some((value) => value === null)) return "unknown";
+	const platforms = (settings.SUPPORTED_PLATFORMS || settings.SDKROOT || "").split(/\s+/).filter(Boolean);
+	if (platforms.some((platform) => !/^(?:iphoneos|iphonesimulator|macosx|appletvos|appletvsimulator|watchos|watchsimulator|xros|xrsimulator|driverkit)(?:[0-9.]+)?$/.test(platform))) return "unknown";
+	if (platforms.length) return platforms.some((platform) => /^iphone(?:os|simulator)/.test(platform)) ? "ios" : "other";
+	return settings.IPHONEOS_DEPLOYMENT_TARGET ? "ios" : "unknown";
+}
+function applicationTargets(project) {
+	return [...project.objects].filter(([, target]) => target.isa === "PBXNativeTarget" && pbxString(target.productType) === "com.apple.product-type.application" && configurations(project, target).some((config) => applicationPlatform(project, target, pbxString(config.name) ?? "") !== "other"));
+}
+function sharedSchemes(container, projects) {
+	const schemes = [];
+	for (const owner of /* @__PURE__ */ new Set([container, ...projects.map((project) => project.path)])) {
+		const directory = join(owner, "xcshareddata", "xcschemes");
+		if (!existsSync(directory)) continue;
+		for (const file of readdirSync(directory).filter((name) => name.endsWith(".xcscheme")).toSorted()) {
+			const path = join(directory, file);
+			const scheme = xml(path);
+			const reference = (scheme.getElementsByTagName("LaunchAction").item(0)?.getElementsByTagName("BuildableProductRunnable").item(0))?.getElementsByTagName("BuildableReference").item(0);
+			if (!reference) continue;
+			const target = reference.getAttribute("BlueprintIdentifier");
+			const location = reference.getAttribute("ReferencedContainer");
+			if (!target || !location?.startsWith("container:")) continue;
+			const referenced = realpathSync(resolve(dirname(owner), location.slice(10)));
+			const project = projects.find((candidate) => candidate.path === referenced);
+			if (!project || !applicationTargets(project).some(([id]) => id === target)) continue;
+			schemes.push({
+				name: basename(file, ".xcscheme"),
+				path,
+				project,
+				target,
+				buildScripts: scheme.getElementsByTagName("ExecutionAction").length > 0
+			});
+		}
+	}
+	for (const project of projects) for (const [target, value] of applicationTargets(project)) {
+		const name = pbxString(value.name);
+		if (name && !schemes.some((scheme) => scheme.project === project && scheme.target === target)) schemes.push({
+			name,
+			path: null,
+			project,
+			target,
+			buildScripts: false
+		});
+	}
+	return schemes;
+}
+function containers(root) {
+	const entries = readdirSync(root).toSorted();
+	const workspaces = entries.filter((name) => name.endsWith(".xcworkspace"));
+	const projects = entries.filter((name) => name.endsWith(".xcodeproj"));
+	const result = [];
+	const claimed = /* @__PURE__ */ new Set();
+	for (const file of workspaces) {
+		const path = join(root, file);
+		const models = workspaceProjects(path).flatMap((project) => {
+			if (!existsSync(project) && existsSync(join(root, "Podfile")) && project === join(root, "Pods", "Pods.xcodeproj")) return [];
+			return [readNativeXcodeModel(project)];
+		});
+		for (const model of models) claimed.add(model.path);
+		result.push({
+			path,
+			projects: models,
+			schemes: sharedSchemes(path, models)
+		});
+	}
+	for (const file of projects) {
+		const path = join(root, file);
+		if (claimed.has(realpathSync(path))) continue;
+		const model = readNativeXcodeModel(path);
+		result.push({
+			path,
+			projects: [model],
+			schemes: sharedSchemes(path, [model])
+		});
+	}
+	return result;
+}
+function selectNativeXcodeProject(root, scheme, configuration = "Debug") {
+	let available;
+	try {
+		available = containers(root);
+	} catch (error) {
+		if (error instanceof NativeXcodeError) throw error;
+		throw new NativeXcodeError(`Could not read native Xcode project: ${error.message}`, "Repair the project/workspace and its referenced files in Xcode, then retry.");
+	}
+	const choices = available.flatMap((container) => container.schemes.map((candidate) => ({
+		container,
+		candidate
+	})));
+	const matching = scheme === void 0 ? choices : choices.filter(({ candidate }) => candidate.name === scheme);
+	if (matching.length !== 1) throw new NativeXcodeError(matching.length ? `Native Xcode application selection is ambiguous${scheme ? ` for scheme ${JSON.stringify(scheme)}` : ""}.` : `No runnable native iOS application${scheme ? ` with scheme ${JSON.stringify(scheme)}` : ""} was found.`, choices.length ? `Select one shared application scheme with --scheme or ios.scheme. Candidates: ${choices.map(({ container, candidate }) => `${relative(root, container.path)}: ${candidate.name}`).join(", ")}. Duplicate container/scheme names must be made unambiguous in Xcode.` : "Open the intended project in Xcode and add a shared scheme whose Run action selects an iOS application.");
+	const { container, candidate } = matching[0];
+	const target = candidate.project.objects.get(candidate.target);
+	const names = configurations(candidate.project, target).map((config) => pbxString(config.name));
+	if (!names.includes(configuration)) throw new NativeXcodeError(`Configuration ${JSON.stringify(configuration)} does not exist for ${candidate.name}.`, `Select --configuration or ios.configuration from: ${names.join(", ")}.`);
+	const platform = applicationPlatform(candidate.project, target, configuration);
+	if (platform === "other") throw new NativeXcodeError(`Configuration ${JSON.stringify(configuration)} does not target iOS for ${candidate.name}.`, "Select an iOS application configuration in Xcode.");
+	const workspace = container.path.endsWith(".xcworkspace");
+	return {
+		container: {
+			path: container.path,
+			dir: dirname(container.path),
+			kind: workspace ? "workspace" : "project",
+			flag: workspace ? "-workspace" : "-project",
+			name: basename(container.path, workspace ? ".xcworkspace" : ".xcodeproj")
+		},
+		projects: container.projects,
+		scheme: candidate.name,
+		targetId: candidate.target,
+		targetName: pbxString(target.name),
+		targetProject: candidate.project,
+		configuration,
+		settings: buildSettings(candidate.project, target, configuration),
+		platform,
+		schemePath: candidate.path,
+		schemeBuildScripts: candidate.buildScripts
+	};
+}
+const nativeXcodeProjectIntegration = {
+	id: "native-xcode",
+	inspect(root) {
+		if (declaresAppDependency(readPackageJson(root))) return null;
+		let entries;
+		try {
+			entries = readdirSync(root);
+		} catch {
+			return null;
+		}
+		if (!entries.some((entry) => (entry.endsWith(".xcodeproj") || entry.endsWith(".xcworkspace")) && statSync(join(root, entry), { throwIfNoEntry: false })?.isDirectory())) return null;
+		let problem = null;
+		try {
+			if (!containers(root).some((container) => container.schemes.length)) problem = {
+				kind: "not-an-app",
+				message: "This Xcode container has no runnable iOS application.",
+				remedy: "Use an iOS application target and shared Run scheme."
+			};
+		} catch (error) {
+			problem = {
+				kind: "unreadable",
+				message: `Could not read Xcode project inputs: ${error.message}`,
+				remedy: "Repair the project/workspace and its references in Xcode."
+			};
+		}
+		return {
+			root: "candidate",
+			application: problem === null,
+			platforms: () => problem ? [] : ["ios"],
+			validate: (operation) => operation === "ios" ? problem : void 0,
+			ios: async () => (await import("./native-xcode-ios-DP3cHLwu.mjs")).nativeXcodeIosProject(root),
+			doctor: async () => (await import("./native-xcode-ios-DP3cHLwu.mjs")).nativeXcodeDoctor(root)
+		};
+	}
+};
+//#endregion
+//#region src/integrations/project-registry.ts
+function canonicalPath(path) {
+	try {
+		return realpathSync(resolve(path));
+	} catch {
+		return resolve(path);
+	}
+}
+function operationSelection(root, matches, operation) {
+	const results = matches.flatMap((match) => {
+		const problem = match.validate?.(operation);
+		return problem === void 0 ? [] : [{
+			match,
+			problem
+		}];
+	});
+	const unreadable = results.find(({ problem }) => problem?.kind === "unreadable");
+	if (unreadable?.problem) return { problem: unreadable.problem };
+	const providers = results.filter(({ problem }) => problem === null);
+	if (providers.length > 1) return { problem: {
+		kind: "ambiguous",
+		message: `Multiple project integrations support ${operation} at ${root}: ${providers.map(({ match }) => match.id).join(", ")}.`,
+		remedy: "Run this from the directory of the app you intend to use, with one integration for this operation."
+	} };
+	if (providers.length === 1) return { match: providers[0].match };
+	return { problem: results[0]?.problem ?? {
+		kind: "not-an-app",
+		message: `No project integration supports ${operation} at ${root}.`,
+		remedy: "Run this from the directory of a supported app."
+	} };
+}
+function operationProblem(root, matches, operation) {
+	const selected = operationSelection(root, matches, operation);
+	return "problem" in selected ? selected.problem : null;
+}
+function createProjectRegistry(integrations) {
+	const inspect = (root) => integrations.flatMap((integration) => {
+		const match = integration.inspect(root);
+		return match ? [{
+			id: integration.id,
+			...match
+		}] : [];
+	});
+	function findProjectRoot(startDir, read = inspect) {
+		let candidates = [];
+		for (const root of projectRootDirectories(startDir)) {
+			const matches = read(root);
+			const owned = new Set(matches.flatMap((match) => match.ownedRoots ?? []).map(canonicalPath));
+			candidates = candidates.filter((candidate) => !owned.has(candidate));
+			if (matches.some((match) => match.root === "explicit")) return candidates[0] ?? root;
+			if (matches.some((match) => match.root === "candidate")) candidates.push(root);
+		}
+		return candidates[0] ?? null;
+	}
+	function ownedRootProblem(root, matches) {
+		if (matches.some((match) => match.root === "candidate") && !matches.some((match) => match.root === "explicit")) {
+			const owner = findProjectRoot(root, (dir) => dir === root ? matches : inspect(dir));
+			if (owner !== null && owner !== root) return {
+				kind: "not-an-app",
+				message: `${root} belongs to the project at ${owner}.`,
+				remedy: `Run this from ${owner}.`
+			};
+		}
+		return null;
+	}
+	function projectProblem(root, operation) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		return ownedRootProblem(root, matches) ?? operationProblem(root, matches, operation);
+	}
+	function selectAndroid(root) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		const problem = ownedRootProblem(root, matches);
+		if (problem) return { problem };
+		const selected = operationSelection(root, matches, "android");
+		if ("problem" in selected) return selected;
+		if (selected.match.android) return {
+			id: selected.match.id,
+			load: selected.match.android
+		};
+		return { problem: {
+			kind: "not-an-app",
+			message: `The ${selected.match.id} integration does not provide an Android operation.`,
+			remedy: "Use an integration with an Android build and runtime recipe."
+		} };
+	}
+	function selectMacos(root) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		const problem = ownedRootProblem(root, matches);
+		if (problem) return { problem };
+		const selected = operationSelection(root, matches, "macos");
+		if ("problem" in selected) return selected;
+		if (selected.match.macos) return { load: selected.match.macos };
+		return { problem: {
+			kind: "not-an-app",
+			message: `The ${selected.match.id} integration does not provide a macOS operation.`,
+			remedy: "Use an integration with a macOS build recipe."
+		} };
+	}
+	function selectWeb(root) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		const problem = ownedRootProblem(root, matches);
+		if (problem) return { problem };
+		const selected = operationSelection(root, matches, "web");
+		if ("problem" in selected) return selected;
+		if (selected.match.web) return { load: selected.match.web };
+		return { problem: {
+			kind: "not-an-app",
+			message: `The ${selected.match.id} integration does not provide a web operation.`,
+			remedy: "Use an integration with a web runtime recipe."
+		} };
+	}
+	function selectIos(root) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		const problem = ownedRootProblem(root, matches);
+		if (problem) return { problem };
+		const selected = operationSelection(root, matches, "ios");
+		if ("problem" in selected) return selected;
+		if (selected.match.ios) return {
+			id: selected.match.id,
+			load: selected.match.ios
+		};
+		return { problem: {
+			kind: "not-an-app",
+			message: `The ${selected.match.id} integration does not provide an iOS operation.`,
+			remedy: "Use an integration with an iOS build and runtime recipe."
+		} };
+	}
+	function isMobileProject(root) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		return ownedRootProblem(root, matches) === null && (operationProblem(root, matches, "ios") === null || operationProblem(root, matches, "android") === null);
+	}
+	function selectDoctor(root, platform) {
+		root = canonicalPath(root);
+		const matches = inspect(root);
+		const selected = (platform ? [platform] : [
+			"ios",
+			"android",
+			"macos",
+			"dev-server"
+		]).map((operation) => ({
+			operation,
+			result: operationSelection(root, matches, operation)
+		}));
+		const accepted = selected.flatMap(({ operation, result }) => "match" in result && result.match.application ? [{
+			operation,
+			match: result.match
+		}] : []);
+		const invalid = selected.flatMap(({ result }) => "problem" in result ? [result.problem] : []);
+		const problem = ownedRootProblem(root, matches) ?? invalid.find((value) => value.kind === "unreadable" || value.kind === "ambiguous") ?? (accepted.length ? null : invalid[0] ?? {
+			kind: "not-an-app",
+			message: `No project integration recognizes an application at ${root}.`,
+			remedy: "Run this from the directory of a supported app."
+		});
+		const providers = [...new Map(accepted.map(({ match }) => [match.id, match])).values()];
+		return {
+			problem,
+			platforms: problem ? [] : accepted.flatMap(({ operation }) => operation === "ios" || operation === "android" ? [operation] : []),
+			load: async () => problem ? [] : Promise.all(providers.flatMap((match) => match.doctor ? [match.doctor()] : []))
+		};
+	}
+	function keepsWorkspace(root) {
+		const matches = inspect(root);
+		return matches.some((match) => match.application) || [
+			"ios",
+			"android",
+			"dev-server"
+		].some((operation) => operationProblem(root, matches, operation)?.kind === "unreadable");
+	}
+	function detectPlatforms(root, resolved) {
+		const platforms = new Set(inspect(root).flatMap((match) => match.platforms(resolved)));
+		return [
+			"ios",
+			"android",
+			"macos",
+			"web"
+		].filter((platform) => platforms.has(platform));
+	}
+	return {
+		findProjectRoot,
+		projectProblem,
+		selectAndroid,
+		selectIos,
+		selectMacos,
+		selectWeb,
+		selectDoctor,
+		isMobileProject,
+		keepsWorkspace,
+		detectPlatforms
+	};
+}
+//#endregion
+//#region src/integrations/projects.ts
+const expo = {
+	mode: MODE_EXPO,
+	loadDevServer: async () => (await import("./server-expo-DV43vep4.mjs")).startExpoServer,
+	platforms(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)) return explicit.filter((platform) => platform === "ios" || platform === "android" || platform === "web");
+		const pkg = readPackageJson(root);
+		return [
+			"ios",
+			"android",
+			..."react-native-web" in {
+				...pkg?.dependencies,
+				...pkg?.devDependencies
+			} || isPackageResolvable(root, "react-native-web") ? ["web"] : []
+		];
+	}
+};
+const reactNative = {
+	mode: MODE_BARE,
+	loadDevServer: async () => (await import("./server-bare-dWjAarki.mjs")).startBareServer,
+	platforms(root, { context, settings }) {
+		if (!declaresAppDependency(readPackageJson(root))) return [];
+		const platforms = [];
+		let ios = [];
+		try {
+			ios = readdirSync(resolveIosProjectDir(settings, root).dir);
+		} catch {}
+		if (ios.some((name) => name.endsWith(".xcodeproj") || name.endsWith(".xcworkspace"))) platforms.push("ios");
+		const android = resolveAndroidLayout(settings, root, context.repoRoot ?? root);
+		if (android.custom ? existsSync(android.moduleDir) : [
+			"build.gradle",
+			"build.gradle.kts",
+			"settings.gradle",
+			"settings.gradle.kts"
+		].some((name) => existsSync(join(android.gradleRoot, name)))) platforms.push("android");
+		return platforms;
+	}
+};
+const projectRegistry = createProjectRegistry([
+	{
+		id: "react-native",
+		inspect(root) {
+			const problem = appProjectProblem(root, loadPackageJson(root));
+			return {
+				root: existsSync(join(root, "package.json")) ? "explicit" : false,
+				application: problem === null,
+				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-SCTK_CT5.mjs")).reactNativeIosProject(root, settings),
+				android: async (resolved) => (await import("./react-native-android-chm1DMlA.mjs")).reactNativeAndroidProject(root, resolved),
+				doctor: async () => (await import("./react-native-doctor-DYXoh-6I.mjs")).reactNativeProjectDoctor(root)
+			};
+		}
+	},
+	nativeAndroidIntegration,
+	{
+		id: "swift-package",
+		inspect(root) {
+			if (!existsSync(join(root, "Package.swift"))) return null;
+			return {
+				root: "explicit",
+				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-afeNUExW.mjs")).swiftpmMacosProject(root),
+				doctor: async () => {
+					const { macosToolchain } = await import("./toolchain-BIupIro1.mjs");
+					return {
+						inspect: () => [],
+						offloadTargets: ({ options: { host = process.platform, platform } }) => host === "darwin" && platform === void 0 ? async () => [{
+							platform: "macos",
+							local: macosToolchain()
+						}] : null
+					};
+				}
+			};
+		}
+	},
+	{
+		id: "browser-web",
+		inspect(root) {
+			return {
+				root: false,
+				application: false,
+				platforms: ({ settings }) => webSettings(settings).url !== null ? ["web"] : [],
+				validate: (operation) => operation === "web" ? null : void 0,
+				web: async () => (await import("./browser-web-CzBmhmgs.mjs")).browserWebProject(root)
+			};
+		}
+	},
+	nativeXcodeProjectIntegration
+]);
+const detectPlatforms = projectRegistry.detectPlatforms;
+function nativeProjectIntegration(root, isExpo = detectIsExpo) {
+	return isExpo(root) ? expo : reactNative;
+}
+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;
+}
+//#endregion
+//#region src/workspace/project.ts
+const findProjectRoot = projectRegistry.findProjectRoot;
+const projectProblem = projectRegistry.projectProblem;
+const isMobileProject = projectRegistry.isMobileProject;
+function projectShortcut(path, proj) {
+	if (proj?.label) return proj.label;
+	const rootPath = findEnclosingWorktreeRoot(path);
+	if (rootPath && rootPath !== path) return `${projectShortcut(rootPath, getProject(rootPath))}/${path.split("/").pop() || path}`;
+	return path.split("/").pop() || path;
+}
+function ownedDeviceLabel(projectPath) {
+	const app = realpathSync$1(projectPath);
+	const root = repoRoot(app);
+	const appLabel = basename$1(app);
+	if (!root) return appLabel;
+	const worktreeLabel = basename$1(realpathSync$1(root));
+	return worktreeLabel === appLabel ? appLabel : `${worktreeLabel}-${appLabel}`;
+}
+const NO_PROJECT_REFUSAL = {
+	code: "STIM_NO_PROJECT",
+	message: "No supported app project was found from this directory.",
+	remedy: "Run this from the directory of a supported app."
+};
+function findServerWorkspace(startDir, registry = projectRegistry) {
+	const nearest = registry.findProjectRoot(startDir);
+	if (!nearest) return null;
+	if (registry.keepsWorkspace(nearest)) return {
+		root: nearest,
+		from: null
+	};
+	if (Object.keys(getProject(nearest)?.ports ?? {}).length) return {
+		root: nearest,
+		from: null
+	};
+	const top = repoRoot(nearest);
+	if (!top) return {
+		root: nearest,
+		from: null
+	};
+	const worktree = expandedRealpath(top);
+	const apps = Object.keys(loadConfig$1()?.projects ?? {}).filter((path) => {
+		if (path === nearest || !isPathPrefix(worktree, expandedRealpath(path)) || !registry.isMobileProject(path)) return false;
+		const owner = repoRoot(path);
+		return owner !== null && expandedRealpath(owner) === worktree;
+	});
+	return apps.length === 1 ? {
+		root: apps[0],
+		from: nearest
+	} : {
+		root: nearest,
+		from: null
+	};
+}
+function findCommandWorkspace(startDir, note = (line) => console.error(line)) {
+	const workspace = findServerWorkspace(startDir);
+	if (workspace?.from) note(`Using the Stim workspace ${workspace.root}: ${workspace.from} is not a React Native or Expo app.`);
+	return workspace?.root ?? null;
+}
+function expandedRealpath(path) {
+	try {
+		return realpathSync$1.native(path);
+	} catch {
+		return resolve$1(path);
+	}
+}
+//#endregion
+export { clearWorkspaceSupervisor as A, MODE_BARE as C, clearManagedMetroTunnel as D, clearExpoMetroTunnel as E, readWorkspaceLaunches as F, workspaceDevServerMode as I, writePidFile as L, readPidFile as M, readRemoteSession as N, clearRemoteSession as O, readRemoteSessionId as P, writeWorkspaceLaunch as R, resolvePackageJson as S, MODE_EXPO as T, detectIsExpo as _, isMobileProject as a, readAppConfigText as b, projectShortcut as c, projectRegistry as d, NativeXcodeError as f, appProjectProblem as g, selectNativeXcodeProject as h, findServerWorkspace as i, readMetroTunnel as j, clearWorkspaceLaunches as k, detectPlatforms as l, pbxString as m, findCommandWorkspace as n, ownedDeviceLabel as o, pbxReferences as p, findProjectRoot as r, projectProblem as s, NO_PROJECT_REFUSAL as t, nativeProjectIntegration as u, detectTutorial as v, MODE_COMMAND as w, readAppJson as x, isPackageResolvable as y };