stim 1.13.0 → 1.15.0

package/dist/prebuild-BvxDlD6C.mjs

@@ -0,0 +1,213 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState } from "./workspace-state-CL2V2Ons.mjs";
+import { r as detectIsExpo } from "./project-CV3tDFHl.mjs";
+import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { i as expoBinRefusal, r as expoBinPath } from "./server-expo-DhtX6bom.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/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-DGeclhvO.mjs → project-CV3tDFHl.mjs}

@@ -1,7 +1,8 @@
-import { _ as loadConfig, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-0jCcMM0E.mjs";
-import { y as repoRoot } from "./worktree-DeBQSVtR.mjs";
+import { _ as loadConfig$1, g as isPathPrefix, l as findEnclosingWorktreeRoot, p as getProject } from "./config-D0DbpZtM.mjs";
+import { y as repoRoot } from "./worktree-C0c5Udwa.mjs";
 import { existsSync, readFileSync, 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;
@@ -213,4 +204,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 { findProjectRoot$1 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 };

package/dist/pull-request-pxnDCQzn.mjs

@@ -0,0 +1,322 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+//#region src/workspace/pull-request.ts
+const GH_TIMEOUT_MS = 2e4;
+const GH_ENV = {
+	GH_PROMPT_DISABLED: "1",
+	GH_NO_UPDATE_NOTIFIER: "1",
+	NO_COLOR: "1"
+};
+const GH_SCALAR_FIELDS = "number,state,url,headRefOid,mergedAt,closedAt,isCrossRepository,isDraft";
+const GH_FIELDS = `${GH_SCALAR_FIELDS},headRepository,headRepositoryOwner`;
+const GH_GRAPHQL_REPO_SELECTION = "headRepository { name } headRepositoryOwner { login }";
+const GH_DETAIL_FIELDS = "title reviewDecision commits(last: 1) { nodes { commit { statusCheckRollup { contexts(first: 0) { checkRunCountsByState { state count } statusContextCountsByState { state count } } } } } }";
+const SIGNED_OUT_EXIT = 4;
+const PASSING = /* @__PURE__ */ new Set([
+	"SUCCESS",
+	"NEUTRAL",
+	"SKIPPED",
+	"COMPLETED"
+]);
+const FAILING = /* @__PURE__ */ new Set([
+	"FAILURE",
+	"ERROR",
+	"TIMED_OUT",
+	"CANCELLED",
+	"ACTION_REQUIRED",
+	"STARTUP_FAILURE",
+	"STALE"
+]);
+const PENDING = /* @__PURE__ */ new Set([
+	"QUEUED",
+	"IN_PROGRESS",
+	"WAITING",
+	"PENDING",
+	"REQUESTED",
+	"EXPECTED"
+]);
+/** Sums a head commit's check runs and commit statuses by outcome; null when the commit has no checks. */
+function checkCounts(rollup) {
+	if (!rollup) return null;
+	const counts = {
+		passing: 0,
+		failing: 0,
+		pending: 0
+	};
+	const contexts = rollup.contexts;
+	for (const { state, count } of [...contexts?.checkRunCountsByState ?? [], ...contexts?.statusContextCountsByState ?? []]) {
+		if (!Number.isInteger(count) || count <= 0) continue;
+		if (PASSING.has(state)) counts.passing += count;
+		else if (FAILING.has(state)) counts.failing += count;
+		else if (PENDING.has(state)) counts.pending += count;
+	}
+	return counts;
+}
+function reviewDecisionOf(value) {
+	if (value === "APPROVED") return "approved";
+	if (value === "CHANGES_REQUESTED") return "changes-requested";
+	if (value === "REVIEW_REQUIRED") return "review-required";
+	return null;
+}
+function detailOf(pull) {
+	if (typeof pull.title !== "string") return {};
+	return {
+		title: pull.title,
+		reviewDecision: reviewDecisionOf(pull.reviewDecision),
+		checks: checkCounts(pull.commits?.nodes?.[0]?.commit?.statusCheckRollup)
+	};
+}
+function stateOf(state) {
+	if (state === "OPEN") return "open";
+	if (state === "MERGED") return "merged";
+	if (state === "CLOSED") return "closed";
+	return null;
+}
+function epoch(text) {
+	const at = text ? Date.parse(text) : NaN;
+	return Number.isFinite(at) ? at : null;
+}
+function headRepoOf(pull) {
+	const owner = pull.headRepositoryOwner?.login;
+	const name = pull.headRepository?.name;
+	return owner && name ? `${owner.toLowerCase()}/${name.toLowerCase()}` : null;
+}
+/**
+* Picks the pull request that describes `head` among those `gh pr list --head <branch>` returned. One whose head is
+* `head` wins, then one whose head contains `head`, then one whose head `head` contains. An open one wins a tier,
+* then the newest. A pull request unrelated to `head` is from an earlier use of the branch name and is ignored. A
+* cross-repository pull request is kept only when its head repository is one of `ownRepos` (this checkout's own git
+* remotes, lowercased "owner/name"); otherwise it only shares the branch name with a stranger's fork and is ignored.
+* `isAncestor(a, b)` answers whether commit `a` is an ancestor of commit `b`, and false when git cannot tell.
+*/
+function selectPullRequest(pulls, head, isAncestor, ownRepos = /* @__PURE__ */ new Set()) {
+	const known = pulls.flatMap((pull) => {
+		if (!pull || typeof pull !== "object") return [];
+		const state = stateOf(pull.state);
+		if (!state || !pull.headRefOid) return [];
+		if (pull.isCrossRepository) {
+			const repo = headRepoOf(pull);
+			if (!repo || !ownRepos.has(repo)) return [];
+		}
+		return [{
+			pull,
+			state
+		}];
+	});
+	const tiers = [
+		known.filter(({ pull }) => pull.headRefOid === head),
+		known.filter(({ pull }) => pull.headRefOid !== head && isAncestor(head, pull.headRefOid)),
+		known.filter(({ pull }) => pull.headRefOid !== head && isAncestor(pull.headRefOid, head))
+	];
+	const tier = tiers.findIndex((entries) => entries.length > 0);
+	if (tier < 0) return null;
+	const { pull, state } = tiers[tier].toSorted((a, b) => Number(b.state === "open") - Number(a.state === "open") || b.pull.number - a.pull.number)[0];
+	return {
+		number: pull.number,
+		state,
+		draft: pull.isDraft === true,
+		url: pull.url,
+		head: pull.headRefOid,
+		containsHead: tier < 2,
+		endedAt: state === "merged" ? epoch(pull.mergedAt) : state === "closed" ? epoch(pull.closedAt) : null,
+		...detailOf(pull)
+	};
+}
+function firstLine(error) {
+	const { stderr, message } = error;
+	const text = String(stderr ?? "").trim() || String(message ?? error);
+	return text.split("\n")[0] ?? text;
+}
+function ghFailure(error, command) {
+	if (error.status === SIGNED_OUT_EXIT) return {
+		unavailable: "gh is not signed in; run `gh auth login`",
+		sticky: true
+	};
+	if (error.code === "ETIMEDOUT") return {
+		unavailable: `${command} did not answer within ${GH_TIMEOUT_MS / 1e3}s`,
+		sticky: true
+	};
+	return {
+		unavailable: `${command} failed: ${firstLine(error)}`,
+		sticky: false
+	};
+}
+function ancestry(cwd) {
+	const exec = getExecutor();
+	return (ancestor, descendant) => exec.runFileQuiet("git", [
+		"-C",
+		cwd,
+		"merge-base",
+		"--is-ancestor",
+		ancestor,
+		descendant
+	]) !== null;
+}
+const REMOTE_URL_RE = /^(?:https?:\/\/(?:[^/@]+@)?[^/]+\/|ssh:\/\/(?:[^/@]+@)?[^/]+\/|(?:[^/@:]+@)?[^/:]+:)([^/]+)\/([^/]+?)(?:\.git)?\/?$/i;
+/**
+* "owner/name", lowercased, parsed out of a git remote URL, or null when it doesn't match: https, `ssh://`, or
+* scp-like (`[user@]host:owner/name`, which also covers an `~/.ssh/config` host alias in place of `user@host`).
+*/
+function parseRemoteRepo(url) {
+	const [, owner, name] = REMOTE_URL_RE.exec(url.trim()) ?? [];
+	return owner && name ? `${owner.toLowerCase()}/${name.toLowerCase()}` : null;
+}
+function localRemoteRepos(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"remote",
+		"-v"
+	]);
+	const repos = /* @__PURE__ */ new Set();
+	for (const line of out ? out.split("\n") : []) {
+		const url = /^\S+\s+(\S+)\s+\((?:fetch|push)\)$/.exec(line)?.[1];
+		const repo = url ? parseRemoteRepo(url) : null;
+		if (repo) repos.add(repo);
+	}
+	return repos;
+}
+/**
+* Asks GitHub, through `gh`, which pull requests have `branch` as their head, run from `cwd` so `gh` picks the
+* repository from its remotes. Each call is one fixed `gh pr list` invocation. Once `gh` is missing, signed out or
+* times out, every later lookup through the same function answers `unavailable` without running it again.
+*/
+function pullRequestLookup() {
+	let unavailable;
+	return (cwd, branch, head) => {
+		const exec = getExecutor();
+		if (unavailable === void 0) unavailable = exec.findExecutable("gh") ? null : "gh is not installed";
+		if (unavailable) return { unavailable };
+		let out;
+		try {
+			out = exec.runFile("gh", [
+				"pr",
+				"list",
+				"--head",
+				branch,
+				"--state",
+				"all",
+				"--limit",
+				"20",
+				"--json",
+				GH_FIELDS
+			], {
+				cwd,
+				timeoutMs: GH_TIMEOUT_MS,
+				env: GH_ENV
+			});
+		} catch (error) {
+			const failure = ghFailure(error, "gh pr list");
+			if (failure.sticky) unavailable = failure.unavailable;
+			return { unavailable: failure.unavailable };
+		}
+		let pulls;
+		try {
+			pulls = JSON.parse(out);
+		} catch {
+			return { unavailable: "gh pr list printed no JSON" };
+		}
+		return { pullRequest: Array.isArray(pulls) ? selectPullRequest(pulls, head, ancestry(cwd), localRemoteRepos(cwd)) : null };
+	};
+}
+function branchesQuery(count, detail) {
+	const variables = Array.from({ length: count }, (_, i) => `, $b${i}: String!`).join("");
+	const nodes = `${GH_SCALAR_FIELDS.replaceAll(",", " ")} ${GH_GRAPHQL_REPO_SELECTION}` + (detail ? ` ${GH_DETAIL_FIELDS}` : "");
+	return `query($owner: String!, $repo: String!${variables}) { repository(owner: $owner, name: $repo) {${Array.from({ length: count }, (_, i) => ` b${i}: pullRequests(headRefName: $b${i}, states: [OPEN, CLOSED, MERGED], first: 20, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { ${nodes} } }`).join("")} } }`;
+}
+/**
+* {@link pullRequestLookup} for every branch of one repository in one fixed `gh api graphql` call run from `repo`,
+* which asks for the same 20 newest pull requests of each head branch that `gh pr list --head` returns. `gh` fills
+* `{owner}` and `{repo}` from the remotes of `repo`; branch names travel as variables. Once `gh` is missing, signed
+* out or times out, every later call through the same function answers `unavailable` without running it again.
+* With `detail`, it also asks for each pull request's title, review decision and head commit check counts.
+*/
+function pullRequestLookups({ detail = false } = {}) {
+	let unavailable;
+	return async (repo, queries) => {
+		const exec = getExecutor();
+		if (unavailable === void 0) unavailable = exec.findExecutable("gh") ? null : "gh is not installed";
+		const all = (lookup) => queries.map(() => lookup);
+		if (unavailable) return all({ unavailable });
+		if (!queries.length) return [];
+		const args = [
+			"api",
+			"graphql",
+			"-F",
+			"owner={owner}",
+			"-F",
+			"repo={repo}"
+		];
+		queries.forEach(({ branch }, i) => args.push("-f", `b${i}=${branch}`));
+		args.push("-f", `query=${branchesQuery(queries.length, detail)}`);
+		let out;
+		try {
+			out = await exec.runFileAsync("gh", args, {
+				cwd: repo,
+				timeoutMs: GH_TIMEOUT_MS,
+				env: GH_ENV
+			});
+		} catch (error) {
+			const failure = ghFailure(error, "gh api graphql");
+			if (failure.sticky) unavailable = failure.unavailable;
+			return all({ unavailable: failure.unavailable });
+		}
+		let found;
+		try {
+			found = JSON.parse(out).data?.repository;
+		} catch {
+			return all({ unavailable: "gh api graphql printed no JSON" });
+		}
+		if (!found) return all({ unavailable: "gh api graphql printed no repository" });
+		const ownRepos = localRemoteRepos(repo);
+		return queries.map(({ cwd, head }, i) => {
+			const pulls = found[`b${i}`]?.nodes;
+			return { pullRequest: Array.isArray(pulls) ? selectPullRequest(pulls, head, ancestry(cwd), ownRepos) : null };
+		});
+	};
+}
+/** The merged or closed pull request whose commits include HEAD, which makes the worktree removable. */
+function endedPullRequest(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	return pr && pr.state !== "open" && pr.containsHead ? pr : null;
+}
+/** "PR #123 merged", for reports. */
+function describePullRequest(pr) {
+	return `PR #${pr.number} ${pr.state}`;
+}
+/**
+* Looks up the pull request of each worktree's branch and HEAD, with one {@link pullRequestLookups} call per
+* repository. The map holds null for a worktree without one, and leaves out a worktree whose HEAD git cannot read
+* or whose lookup was unavailable.
+*/
+function worktreePullRequests() {
+	const lookup = pullRequestLookups();
+	return async (worktrees) => {
+		const exec = getExecutor();
+		const repos = /* @__PURE__ */ new Map();
+		for (const { path, branch, repository } of worktrees) {
+			let head;
+			try {
+				head = (await exec.runFileAsync("git", [
+					"-C",
+					path,
+					"rev-parse",
+					"HEAD"
+				], { timeoutMs: 5e3 })).trim();
+			} catch {
+				continue;
+			}
+			repos.set(repository, [...repos.get(repository) ?? [], {
+				cwd: path,
+				branch,
+				head
+			}]);
+		}
+		const found = /* @__PURE__ */ new Map();
+		for (const [repo, queries] of repos) (await lookup(repo, queries)).forEach((result, i) => {
+			if ("pullRequest" in result) found.set(queries[i].cwd, result.pullRequest);
+		});
+		return found;
+	};
+}
+//#endregion
+export { pullRequestLookup as a, worktreePullRequests as c, parseRemoteRepo as i, describePullRequest as n, pullRequestLookups as o, endedPullRequest as r, selectPullRequest as s, checkCounts as t };