@overdeck/desktop 0.45.23 → 0.46.0

package/server/flywheel-merge-order-BJv1DZz1.js

@@ -0,0 +1,462 @@
+import { Gn as init_projects, Mn as findProjectByPathSync, Rn as getProjectSwarmHotspots, ar as resolveProjectFromIssueSync } from "./config-yaml-CmOPzmBb.js";
+import { _ as mergeGateEligibility, f as init_review_status, m as loadReviewStatuses, u as getReviewStatusSync } from "./review-status-yljtTd-q.js";
+import { n as resolveGitHubIssueSync, t as init_tracker_utils } from "./tracker-utils-L0FKtjq2.js";
+import { l as init_dag, r as compileGlob } from "./dag-ombYYt4s.js";
+import { n as computeIssueFootprint, r as init_swarm_readiness } from "./swarm-readiness-BV14DF5N.js";
+import { c as classifyIssue, h as isAutoPickable, m as init_pickup } from "./pickup-D8xtG1J2.js";
+import { Effect } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+//#region ../../lib/flywheel-merge-order.ts
+init_review_status();
+init_tracker_utils();
+init_pickup();
+init_dag();
+init_swarm_readiness();
+init_projects();
+function issueNumber(issueId) {
+	const match = issueId.match(/\d+$/);
+	return match ? parseInt(match[0], 10) : 0;
+}
+/**
+* PAN-1691 conflict-aware merge order. Disjoint (no-conflict) items come first
+* so they can batch through in a single verification pass; then conflicting
+* items broadest-file-footprint first, so the remaining cluster members rebase
+* once onto the worst offender instead of repeatedly. Issue number is the
+* stable tiebreak within each tier. Pure — exported for testing.
+*/
+function orderMergeCandidates(items) {
+	return [...items].sort((a, b) => {
+		const aConf = a.conflictCount > 0 ? 1 : 0;
+		const bConf = b.conflictCount > 0 ? 1 : 0;
+		if (aConf !== bConf) return aConf - bConf;
+		if (aConf === 1 && a.footprint !== b.footprint) return b.footprint - a.footprint;
+		return issueNumber(a.issueId) - issueNumber(b.issueId);
+	});
+}
+/**
+* PAN-1691 merge-train plan. Partitions the conflict-aware order into the run of
+* disjoint candidates — which can all merge in a single verification pass — and
+* the conflicting remainder, which must serialize broadest-footprint first.
+* Pure; the executor consumes this once the merge-train flag is enabled.
+*/
+function planMergeTrain(candidates) {
+	const ordered = orderMergeCandidates(candidates);
+	return {
+		batch: ordered.filter((c) => c.conflictCount === 0).map((c) => c.issueId),
+		serialize: ordered.filter((c) => c.conflictCount > 0).map((c) => c.issueId),
+		order: ordered.map((c) => c.issueId)
+	};
+}
+function declaredIssueFootprint(issueId, doc) {
+	return {
+		issueId,
+		files: computeIssueFootprint(doc),
+		source: "declared"
+	};
+}
+function pathMatchesAnyCompiled(filePath, patterns) {
+	return patterns.some((pattern) => pattern.regex.test(filePath) || pattern.exactDirectory === filePath);
+}
+function normalizedFootprintFiles(files, hotspots) {
+	const normalized = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		if (!file || pathMatchesAnyCompiled(file, hotspots)) continue;
+		normalized.add(file);
+	}
+	return normalized;
+}
+function sourcePriority(source) {
+	return source === "actual" ? 2 : 1;
+}
+function computePredictedConflictSignals(footprints, options = {}) {
+	const hotspots = (options.hotspots ?? []).map(compileGlob);
+	const byIssue = /* @__PURE__ */ new Map();
+	for (const footprint of footprints) {
+		const files = normalizedFootprintFiles(footprint.files, hotspots);
+		const current = byIssue.get(footprint.issueId);
+		if (!current || sourcePriority(footprint.source) > sourcePriority(current.source)) {
+			byIssue.set(footprint.issueId, {
+				issueId: footprint.issueId,
+				source: footprint.source,
+				files
+			});
+			continue;
+		}
+		if (sourcePriority(footprint.source) === sourcePriority(current.source)) for (const file of files) current.files.add(file);
+	}
+	const conflictsMap = /* @__PURE__ */ new Map();
+	const entries = Array.from(byIssue.values());
+	for (let i = 0; i < entries.length; i++) for (let j = i + 1; j < entries.length; j++) {
+		const left = entries[i];
+		const right = entries[j];
+		if (![...left.files].some((file) => right.files.has(file))) continue;
+		if (!conflictsMap.has(left.issueId)) conflictsMap.set(left.issueId, /* @__PURE__ */ new Set());
+		if (!conflictsMap.has(right.issueId)) conflictsMap.set(right.issueId, /* @__PURE__ */ new Set());
+		conflictsMap.get(left.issueId).add(right.issueId);
+		conflictsMap.get(right.issueId).add(left.issueId);
+	}
+	return entries.map((entry) => {
+		const conflictsWith = [...conflictsMap.get(entry.issueId) ?? []].sort((a, b) => issueNumber(a) - issueNumber(b));
+		return {
+			issueId: entry.issueId,
+			source: entry.source,
+			footprint: entry.files.size,
+			conflictCount: conflictsWith.length,
+			conflictsWith
+		};
+	});
+}
+/**
+* PAN-1691 on-demand UAT candidate. In auto-merge-OFF mode the disjoint "batch"
+* (everything that can merge together in one verification pass) is bundled onto
+* a single throwaway branch the human UATs in one sitting. Pure — `dateIso` is
+* injected, and it reads the already-computed `batchGroup` off the merge queue.
+*/
+function planUatCandidate(queue, opts) {
+	const bundled = queue.filter((i) => i.batchGroup === "batch").map((i) => i.issueId);
+	const day = opts.dateIso.slice(0, 10);
+	return {
+		branchName: `uat/${opts.label ?? "candidate"}-${day}`,
+		bundled
+	};
+}
+const branchExists = (branch, cwd) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const cmd = ChildProcess.make("git", [
+		"rev-parse",
+		"--verify",
+		branch
+	], { cwd });
+	return yield* spawner.exitCode(cmd).pipe(Effect.map((code) => code === 0), Effect.orElseSucceed(() => false));
+});
+const changedFilesVsMain = (branch, cwd, base = "main") => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const cmd = ChildProcess.make("git", [
+		"diff",
+		"--name-only",
+		`${base}...${branch}`
+	], { cwd });
+	return yield* spawner.string(cmd).pipe(Effect.map((stdout) => new Set(stdout.trim().split("\n").filter(Boolean))), Effect.orElseSucceed(() => /* @__PURE__ */ new Set()));
+});
+const MERGE_QUEUE_GIT_CONCURRENCY = 4;
+/** Default eligibility: the issue's review-status record, read synchronously. */
+function reviewRecordEligibility(issueId) {
+	return mergeGateEligibility(getReviewStatusSync(issueId.toUpperCase()));
+}
+/**
+* Server-side PR URL resolution for merge-queue items: prefer the review
+* status record, fall back to the GitHub repo + PR number — the browser never
+* guesses repo slugs.
+*/
+function resolveMergeQueuePrUrl(item) {
+	const issueId = item.issueId.toUpperCase();
+	const reviewStatus = getReviewStatusSync(issueId);
+	if (reviewStatus?.prUrl) return reviewStatus.prUrl;
+	const prNumber = reviewStatus?.prNumber ?? item.pr;
+	if (prNumber === void 0) return void 0;
+	const githubIssue = resolveGitHubIssueSync(issueId);
+	if (!githubIssue.isGitHub) return void 0;
+	return `https://github.com/${githubIssue.owner}/${githubIssue.repo}/pull/${prNumber}`;
+}
+/**
+* PAN-1696 ready-set-source: List all merge-eligible candidates from review-status DB for a given project.
+* No flywheel run required — sources directly from persistent pipeline state.
+* Returns an array of candidate items compatible with computeMergeQueueFromCandidates.
+*/
+function listEligibleCandidatesByProject(projectRoot) {
+	const project = findProjectByPathSync(projectRoot);
+	if (!project) return [];
+	const candidates = [];
+	const allStatuses = loadReviewStatuses();
+	for (const [issueId, rs] of Object.entries(allStatuses)) {
+		const issueProject = resolveProjectFromIssueSync(issueId);
+		if (!issueProject || issueProject.projectPath !== project.path) continue;
+		if (rs.deaconIgnored === true) continue;
+		if (rs.readyForMerge !== true) continue;
+		if (!mergeGateEligibility(rs).eligible) continue;
+		candidates.push({
+			issueId,
+			title: issueId,
+			pr: rs.prNumber
+		});
+	}
+	return candidates;
+}
+/**
+* PAN-1696 ready-set-source: Compute merge queue from a pre-filtered candidate list.
+* Accepts candidates from review-status or flywheel pipeline — decouples the source.
+* This refactored version extracts the core conflict-analysis logic from computeMergeQueue.
+*/
+const computeMergeQueueFromCandidates = (candidates, projectRoot, options = {}) => Effect.gen(function* () {
+	if (candidates.length === 0) return [];
+	const gitConcurrency = Math.max(1, Math.floor(options.gitConcurrency ?? 4));
+	const branches = candidates.map((item) => `feature/${item.issueId.toLowerCase()}`);
+	const existsFlags = yield* Effect.all(branches.map((branch) => branchExists(branch, projectRoot)), { concurrency: gitConcurrency });
+	const existing = candidates.map((item, i) => ({
+		item,
+		branch: branches[i],
+		exists: existsFlags[i]
+	})).filter(({ exists }) => exists);
+	if (existing.length === 0) return [];
+	const fileSets = yield* Effect.all(existing.map(({ branch }) => changedFilesVsMain(branch, projectRoot)), { concurrency: gitConcurrency });
+	const hotspots = options.hotspots ?? getProjectSwarmHotspots(findProjectByPathSync(projectRoot));
+	const conflictSignals = computePredictedConflictSignals(existing.map((e, i) => ({
+		issueId: e.item.issueId,
+		source: "actual",
+		files: fileSets[i]
+	})), { hotspots });
+	const signalByIssue = new Map(conflictSignals.map((signal) => [signal.issueId, signal]));
+	const conflictsMap = new Map(conflictSignals.map((signal) => [signal.issueId, new Set(signal.conflictsWith)]));
+	return orderMergeCandidates(existing.map((e, i) => ({
+		item: e.item,
+		issueId: e.item.issueId,
+		footprint: signalByIssue.get(e.item.issueId)?.footprint ?? fileSets[i].size,
+		conflictCount: signalByIssue.get(e.item.issueId)?.conflictCount ?? 0
+	}))).map(({ item, conflictCount }, idx) => ({
+		issueId: item.issueId,
+		title: item.title,
+		branchName: `feature/${item.issueId.toLowerCase()}`,
+		pr: item.pr,
+		prUrl: options.getPrUrl?.(item),
+		mergeOrder: idx + 1,
+		conflictsWith: [...conflictsMap.get(item.issueId) ?? []],
+		batchGroup: conflictCount === 0 ? "batch" : "serialize"
+	}));
+});
+/** The `feature/` (or configured) namespace a source branch lives in. */
+function branchNamespace(sourceBranch) {
+	const slash = sourceBranch.lastIndexOf("/");
+	return slash >= 0 ? sourceBranch.slice(0, slash + 1) : "";
+}
+/**
+* Refresh every feature-branch tracking ref in one repo with ONE remote
+* negotiation, and report whether it succeeded.
+*
+* Three things this must get right, each of which caused a real defect:
+*
+*  - **One fetch per repo, not per candidate.** Fetching per candidate/repo pair
+*    performs F x R remote negotiations every reconciler minute, which on a
+*    large ready set can outrun the interval and hold the project's
+*    single-flight slot permanently.
+*  - **Force (`+`) the refspec.** Without it a force-with-lease rebase on the
+*    feature branch makes the update non-fast-forward, so the fetch fails and
+*    the stale tracking ref survives — assembly would then test and promote
+*    obsolete code.
+*  - **Prune.** A deleted remote branch must drop its tracking ref, or the
+*    probe keeps reporting a contribution that no longer exists.
+*
+* Returns false on ANY operational failure (transport, auth, bad repo). The
+* caller must fail closed: a stale ref is indistinguishable from a current one
+* once the fetch is gone, so silently continuing risks assembling old code.
+*/
+const refreshFeatureRefs = (namespaces, cwd) => Effect.gen(function* () {
+	if (namespaces.length === 0) return true;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const refspecs = namespaces.map((ns) => `+refs/heads/${ns}*:refs/remotes/origin/${ns}*`);
+	const cmd = ChildProcess.make("git", [
+		"fetch",
+		"--prune",
+		"origin",
+		...refspecs
+	], { cwd });
+	return yield* spawner.exitCode(cmd).pipe(Effect.map((code) => Number(code) === 0), Effect.orElseSucceed(() => false));
+});
+/**
+* Origin-first feature-branch probe, matching branchHeadSha in
+* uat-generation-deps.ts: work agents push their branches, so the local ref can
+* lag or be missing entirely in a repo the operator never checked out.
+* Returns the ref that exists, or null when neither does.
+*
+* Purely local — refreshFeatureRefs has already contacted the remote for this
+* repo, so `git rev-parse origin/<branch>` now reads a ref that is known
+* current rather than whatever was cached.
+*/
+const resolveFeatureRef = (branch, repoPath) => Effect.gen(function* () {
+	const originRef = `origin/${branch}`;
+	if (yield* branchExists(originRef, repoPath)) return originRef;
+	if (yield* branchExists(branch, repoPath)) return branch;
+	return null;
+});
+/**
+* PAN-3093 polyrepo ready set. The monorepo sibling
+* (computeMergeQueueFromCandidates) derives one `feature/<issue>` branch and
+* runs git against one project root; a polyrepo candidate instead contributes
+* to some subset of the project's member repos, and only those repos with a
+* real feature branch belong in the generation.
+*
+* Conflict prediction runs over the union of each candidate's per-repo changed
+* files, prefixed `<repoKey>:` so the same path in two repos cannot read as an
+* overlap. Hotspot globs are applied per repo BEFORE prefixing — a glob like
+* `package.json` would never match `fe:package.json`.
+*/
+const computePolyrepoMergeQueueFromCandidates = (candidates, reposByIssue, projectRoot, options = {}) => Effect.gen(function* () {
+	if (candidates.length === 0) return [];
+	const gitConcurrency = Math.max(1, Math.floor(options.gitConcurrency ?? 4));
+	const perCandidate = candidates.map((item) => {
+		const configured = reposByIssue.get(item.issueId) ?? [];
+		return {
+			item,
+			configured,
+			repos: configured.filter((repo) => repo.required),
+			readOnlySkipped: configured.filter((repo) => !repo.required)
+		};
+	});
+	const namespacesByRepo = /* @__PURE__ */ new Map();
+	for (const entry of perCandidate) for (const repo of entry.repos) {
+		const existing = namespacesByRepo.get(repo.repoPath) ?? {
+			repoPath: repo.repoPath,
+			namespaces: /* @__PURE__ */ new Set()
+		};
+		existing.namespaces.add(branchNamespace(repo.sourceBranch));
+		namespacesByRepo.set(repo.repoPath, existing);
+	}
+	const refreshResults = yield* Effect.all([...namespacesByRepo.values()].map(({ repoPath, namespaces }) => refreshFeatureRefs([...namespaces], repoPath).pipe(Effect.map((ok) => ({
+		repoPath,
+		ok
+	})))), { concurrency: gitConcurrency });
+	const staleRepoPaths = new Set(refreshResults.filter((r) => !r.ok).map((r) => r.repoPath));
+	if (staleRepoPaths.size > 0) options.onRefreshUnavailable?.([...staleRepoPaths]);
+	const probeJobs = perCandidate.flatMap((entry, candidateIndex) => entry.repos.filter((repo) => !staleRepoPaths.has(repo.repoPath)).map((repo) => ({
+		candidateIndex,
+		repo
+	})));
+	const probeResults = yield* Effect.all(probeJobs.map(({ candidateIndex, repo }) => resolveFeatureRef(repo.sourceBranch, repo.repoPath).pipe(Effect.map((ref) => ({
+		candidateIndex,
+		repo,
+		ref
+	})))), { concurrency: gitConcurrency });
+	const foundByCandidate = perCandidate.map(() => []);
+	for (const { candidateIndex, repo, ref } of probeResults) if (ref !== null) foundByCandidate[candidateIndex].push({
+		repo,
+		ref
+	});
+	const resolved = perCandidate.map((entry, candidateIndex) => {
+		const found = [...foundByCandidate[candidateIndex]].sort((a, b) => a.repo.mergeOrder - b.repo.mergeOrder || a.repo.repoKey.localeCompare(b.repo.repoKey));
+		return {
+			...entry,
+			contributions: found.map(({ repo }) => ({
+				repoKey: repo.repoKey,
+				repoPath: repo.repoPath,
+				branch: repo.sourceBranch,
+				targetBranch: repo.targetBranch,
+				mergeOrder: repo.mergeOrder
+			})),
+			diffRefs: found.map(({ ref }) => ref)
+		};
+	});
+	const contributing = [];
+	for (const entry of resolved) {
+		const unrefreshed = entry.repos.filter((repo) => staleRepoPaths.has(repo.repoPath));
+		if (unrefreshed.length > 0) {
+			options.onExcluded?.(entry.item.issueId, `could not refresh feature refs in ${unrefreshed.map((r) => r.repoKey).join(", ")} — excluding rather than risk assembling stale code`);
+			continue;
+		}
+		if (entry.contributions.length === 0) {
+			const readOnlyNote = entry.readOnlySkipped.length > 0 ? ` (${entry.readOnlySkipped.map((r) => r.repoKey).join(", ")} excluded as read-only)` : "";
+			options.onExcluded?.(entry.item.issueId, entry.repos.length === 0 ? `no writable member repos resolved for this issue${readOnlyNote}` : `no feature branch in any of ${entry.repos.length} writable member repo(s): ${entry.repos.map((r) => r.repoKey).join(", ")}${readOnlyNote}`);
+			continue;
+		}
+		contributing.push({
+			item: entry.item,
+			contributions: entry.contributions,
+			diffRefs: entry.diffRefs
+		});
+	}
+	if (contributing.length === 0) return [];
+	const hotspots = (options.hotspots ?? getProjectSwarmHotspots(findProjectByPathSync(projectRoot))).map(compileGlob);
+	const diffJobs = contributing.flatMap(({ contributions, diffRefs }, candidateIndex) => contributions.map((c, repoIndex) => ({
+		candidateIndex,
+		contribution: c,
+		ref: diffRefs[repoIndex]
+	})));
+	const diffResults = yield* Effect.all(diffJobs.map(({ candidateIndex, contribution, ref }) => changedFilesVsMain(ref, contribution.repoPath, contribution.targetBranch).pipe(Effect.map((files) => ({
+		candidateIndex,
+		files: [...normalizedFootprintFiles(files, hotspots)].map((f) => `${contribution.repoKey}:${f}`)
+	})))), { concurrency: gitConcurrency });
+	const fileSets = contributing.map(() => /* @__PURE__ */ new Set());
+	for (const { candidateIndex, files } of diffResults) for (const file of files) fileSets[candidateIndex].add(file);
+	const conflictSignals = computePredictedConflictSignals(contributing.map((c, i) => ({
+		issueId: c.item.issueId,
+		source: "actual",
+		files: fileSets[i]
+	})));
+	const signalByIssue = new Map(conflictSignals.map((signal) => [signal.issueId, signal]));
+	const conflictsMap = new Map(conflictSignals.map((signal) => [signal.issueId, new Set(signal.conflictsWith)]));
+	return orderMergeCandidates(contributing.map((c, i) => ({
+		item: c.item,
+		contributions: c.contributions,
+		issueId: c.item.issueId,
+		footprint: signalByIssue.get(c.item.issueId)?.footprint ?? fileSets[i].size,
+		conflictCount: signalByIssue.get(c.item.issueId)?.conflictCount ?? 0
+	}))).map(({ item, contributions, conflictCount }, idx) => ({
+		issueId: item.issueId,
+		title: item.title,
+		branchName: `feature/${item.issueId.toLowerCase()}`,
+		pr: item.pr,
+		prUrl: options.getPrUrl?.(item),
+		mergeOrder: idx + 1,
+		conflictsWith: [...conflictsMap.get(item.issueId) ?? []],
+		batchGroup: conflictCount === 0 ? "batch" : "serialize",
+		repoContributions: contributions
+	}));
+});
+/**
+* PAN-1866: Pick the highest-ranked eligible issue from a sequence node list.
+*
+* Eligibility rules:
+* - gate must not be 'blocked' (the `vetoed` pickup state)
+* - no `vetoed` label — an absolute operator hard-stop (PAN-2006)
+* - not in-pipeline (active review/work/test)
+* - no parked labels (`parked`; legacy `needs-design`/`needs-discussion`)
+* - not in the optional exclusion set (e.g. already running agents)
+* - FR-14: must have an xBRIEF spec (ready) or a PRD draft (hasPrd)
+*
+* Returns null when no eligible issue is found.
+*/
+function pickFromSequence(nodes, opts) {
+	const lookups = {
+		labels: opts?.issueLabels ?? (() => []),
+		isPlanned: opts?.isReadyOrHasPrd ?? (() => true),
+		isInPipeline: (issueId) => {
+			const reviewStatus = getReviewStatusSync(issueId.toUpperCase());
+			return reviewStatus !== null && reviewStatus.reviewStatus !== "pending" || (opts?.isInPipeline?.(issueId) ?? false);
+		}
+	};
+	const signalByIssue = new Map((opts?.predictedConflictSignals ?? []).map((signal) => [signal.issueId.toUpperCase(), signal]));
+	const eligible = [...nodes].sort((a, b) => a.rank - b.rank).filter((node) => {
+		const state = classifyIssue(node, lookups);
+		const activeBookMember = opts?.activeBookMembership?.has(node.issue.toUpperCase()) ?? false;
+		if (!isAutoPickable(opts?.requireReady ? state : {
+			...state,
+			ready: true
+		}, opts?.autoPickupBacklog ?? false, activeBookMember)) return false;
+		if (opts?.excludeIssueIds?.has(node.issue)) return false;
+		if (opts?.isAuthorizedIssue && !opts.isAuthorizedIssue(node.issue)) return false;
+		return true;
+	});
+	if (signalByIssue.size > 0) eligible.sort((a, b) => {
+		const aSignal = signalByIssue.get(a.issue.toUpperCase());
+		const bSignal = signalByIssue.get(b.issue.toUpperCase());
+		const aConflicts = aSignal?.conflictCount ?? 0;
+		const bConflicts = bSignal?.conflictCount ?? 0;
+		if (aConflicts !== bConflicts) return aConflicts - bConflicts;
+		return a.rank - b.rank;
+	});
+	for (const node of eligible) {
+		classifyIssue(node, lookups);
+		const signal = signalByIssue.get(node.issue.toUpperCase());
+		return {
+			issueId: node.issue,
+			rank: node.rank,
+			gate: node.gate,
+			planning: node.planning,
+			predictedConflictCount: signal?.conflictCount,
+			predictedConflictsWith: signal?.conflictsWith
+		};
+	}
+	return null;
+}
+//#endregion
+export { computePredictedConflictSignals as a, orderMergeCandidates as c, planUatCandidate as d, resolveMergeQueuePrUrl as f, computePolyrepoMergeQueueFromCandidates as i, pickFromSequence as l, changedFilesVsMain as n, declaredIssueFootprint as o, reviewRecordEligibility as p, computeMergeQueueFromCandidates as r, listEligibleCandidatesByProject as s, MERGE_QUEUE_GIT_CONCURRENCY as t, planMergeTrain as u };
+
+//# sourceMappingURL=flywheel-merge-order-BJv1DZz1.js.map

package/server/flywheel-merge-order-BKw9o6ku.js

@@ -0,0 +1,2 @@
+import { a as computePredictedConflictSignals, c as orderMergeCandidates, d as planUatCandidate, f as resolveMergeQueuePrUrl, i as computePolyrepoMergeQueueFromCandidates, l as pickFromSequence, n as changedFilesVsMain, o as declaredIssueFootprint, p as reviewRecordEligibility, r as computeMergeQueueFromCandidates, s as listEligibleCandidatesByProject, t as MERGE_QUEUE_GIT_CONCURRENCY, u as planMergeTrain } from "./flywheel-merge-order-BJv1DZz1.js";
+export { MERGE_QUEUE_GIT_CONCURRENCY, changedFilesVsMain, computeMergeQueueFromCandidates, computePolyrepoMergeQueueFromCandidates, computePredictedConflictSignals, declaredIssueFootprint, listEligibleCandidatesByProject, orderMergeCandidates, pickFromSequence, planMergeTrain, planUatCandidate, resolveMergeQueuePrUrl, reviewRecordEligibility };