stim 1.18.0 → 1.19.0

package/dist/project-B5eQ1USs.mjs

@@ -0,0 +1,612 @@
+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-DC5jEtd1.mjs";
+import { C as workspaceStateFile, a as updateWorkspaceState, h as supervisorPidFile, o as withWorkspaceStateLock, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-CR9X86xJ.mjs";
+import { G as webSettings, V as settingValueAt, mt as repoRoot } from "./settings-CxgngUZk.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, 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";
+//#region src/supervisor/state.ts
+const MODE_BARE = "bare-inproc";
+const MODE_EXPO = "expo-child";
+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 (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 } = pkg;
+	const deps = {
+		...dependencies,
+		...devDependencies
+	};
+	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/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 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 { 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 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, settings) {
+		const platforms = new Set(inspect(root).flatMap((match) => match.platforms(settings)));
+		return [
+			"ios",
+			"android",
+			"macos",
+			"web"
+		].filter((platform) => platforms.has(platform));
+	}
+	return {
+		findProjectRoot,
+		projectProblem,
+		selectIos,
+		selectMacos,
+		selectWeb,
+		isMobileProject,
+		keepsWorkspace,
+		detectPlatforms
+	};
+}
+//#endregion
+//#region src/integrations/projects.ts
+const expo = {
+	mode: MODE_EXPO,
+	loadDevServer: async () => (await import("./server-expo-DGsdUGX2.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-CkIjnegq.mjs")).startBareServer,
+	platforms(root) {
+		if (!declaresAppDependency(readPackageJson(root))) return [];
+		const platforms = [];
+		let ios = [];
+		try {
+			ios = readdirSync(join(root, "ios"));
+		} catch {}
+		if (ios.some((name) => name.endsWith(".xcodeproj") || name.endsWith(".xcworkspace"))) platforms.push("ios");
+		if ([
+			"build.gradle",
+			"build.gradle.kts",
+			"settings.gradle",
+			"settings.gradle.kts"
+		].some((name) => existsSync(join(root, "android", 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: (settings) => nativeProjectIntegration(root).platforms(root, settings),
+				validate: (operation) => operation === "ios" || operation === "android" || operation === "dev-server" ? problem : void 0,
+				ios: async () => (await import("./react-native-ios-BMh2i25I.mjs")).reactNativeIosProject(root)
+			};
+		}
+	},
+	{
+		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-aJzPAj1t.mjs")).swiftpmMacosProject(root)
+			};
+		}
+	},
+	{
+		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-CDhqQxhv.mjs")).browserWebProject(root)
+			};
+		}
+	}
+]);
+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: "Not in a React Native project (no package.json found).",
+	remedy: "Run this from the app directory -- the one holding package.json."
+};
+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 { readWorkspaceLaunches as A, clearRemoteSession as C, readPidFile as D, readMetroTunnel as E, writeWorkspaceLaunch as M, readRemoteSession as O, clearManagedMetroTunnel as S, clearWorkspaceSupervisor as T, readAppJson as _, isMobileProject as a, MODE_EXPO as b, projectShortcut as c, projectRegistry as d, appProjectProblem as f, readAppConfigText as g, isPackageResolvable as h, findServerWorkspace as i, writePidFile as j, readRemoteSessionId as k, detectPlatforms as l, detectTutorial as m, findCommandWorkspace as n, ownedDeviceLabel as o, detectIsExpo as p, findProjectRoot as r, projectProblem as s, NO_PROJECT_REFUSAL as t, nativeProjectIntegration as u, resolvePackageJson as v, clearWorkspaceLaunches as w, clearExpoMetroTunnel as x, MODE_BARE as y };

package/dist/{pull-request-u4vp7zmK.mjs → pull-request-IHNdMnG8.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 //#region src/workspace/pull-request.ts
 const GH_TIMEOUT_MS = 2e4;
 const GH_ENV = {

package/dist/pull-requests.mjs

@@ -1,2 +1,2 @@
-import { a as pullRequestLookup, c as worktreePullRequests, i as parseRemoteRepo, n as describePullRequest, o as pullRequestLookups, r as endedPullRequest, s as selectPullRequest, t as checkCounts } from "./pull-request-u4vp7zmK.mjs";
+import { a as pullRequestLookup, c as worktreePullRequests, i as parseRemoteRepo, n as describePullRequest, o as pullRequestLookups, r as endedPullRequest, s as selectPullRequest, t as checkCounts } from "./pull-request-IHNdMnG8.mjs";
 export { checkCounts, describePullRequest, endedPullRequest, parseRemoteRepo, pullRequestLookup, pullRequestLookups, selectPullRequest, worktreePullRequests };

package/dist/react-native-ios-BMh2i25I.mjs

@@ -0,0 +1,2 @@
+import { t as reactNativeIosProject } from "./react-native-ios-CSpIxexZ.mjs";
+export { reactNativeIosProject };