pr-merge-queue 0.0.0-stage → 0.0.0

package/dist/unblock-prs/stack.d.mts

@@ -0,0 +1,98 @@
+/**
+ * Stacked pull requests: one whose base is another open pull request's
+ * branch rather than the default branch. Which pull request is on which is
+ * `pr-report-core`'s `stack.mts`, because the reports draw the same stacks;
+ * what this script does about them is decided here.
+ *
+ * The life of a layer, and what this script does at each point:
+ *
+ * 1. **Stacked.** Its base is the layer below, so its diff is its own and its
+ *    turn has not come: it is reported as waiting, and nothing else. It has
+ *    no auto-merge, and must not: nothing holds a pull request onto an
+ *    unprotected branch, so armed it would land in the layer below rather
+ *    than on the default branch. Nothing arms it — `open-pr` arms nothing,
+ *    and this script arms a pull request only when it picks it
+ *    (`armOnPick` in `rebase.mts`), which a stacked one never is.
+ * 2. **The layer below moves.** When this script rebases a pull request, it
+ *    replays every layer stacked on it onto the new head with
+ *    `git rebase --onto <new head> <old head>`, which carries exactly the
+ *    layer's own commits. Otherwise each layer would show the old commits of
+ *    the one below in its diff, and GitHub's own rebase, when that one
+ *    merges, would start from a head the layer does not contain.
+ * 3. **The layer below merges.** GitHub moves this one onto the default
+ *    branch. From then on it is an ordinary pull request, picked and armed
+ *    in its turn like any other, save one thing: it still carries the merged
+ *    layer's commits, so its diff shows that layer's changes as its own. The
+ *    next survey rebases them off with `--onto`, from the head that layer
+ *    merged at to its squash commit, and carries the layers above along —
+ *    without waiting for it to be queued, because that is an undoing of
+ *    GitHub's move, not a turn: it adds nothing from the base, and needs no
+ *    review to have finished. The ruleset merges a branch only when it is up
+ *    to date and only by squash, so that commit's tree is the merged head's,
+ *    and the rebased layer's tree is the one it had: only its history, and
+ *    so its diff, changes. A queued layer is left to its own rebase when it
+ *    is picked, which drops the same commits the same way on its way onto
+ *    the tip.
+ *
+ * A stack here is made by the base alone. GitHub's native stacks are not
+ * landed: GitHub refuses auto-merge on a pull request in one ("Auto-merge is
+ * not supported for stacked pull requests"), and keeps a layer in its stack
+ * after the one below has merged and it has been moved onto the default
+ * branch — so one is reported rather than picked, and merged by hand.
+ */
+import { type NativeStackEntry, type QueueOwner } from 'pr-report-core';
+import type { BaseChange, BranchOf, Classification, PullRequest, RetargetedLayer, StackedOn, TriageContext } from './types.mjs';
+/**
+ * The branch the pull request was stacked on, if the last change of its base
+ * moved it off that branch and onto the default one.
+ */
+export declare const retargetedFrom: (changes: readonly BaseChange[], defaultBranch: string) => string | undefined;
+/** What to report for a stacked pull request in place of anything else. */
+export declare const stackedNote: (pr: PullRequest, parent: number, context: TriageContext) => Classification;
+/**
+ * What to report instead of picking a pull request in one of GitHub's native
+ * stacks, which GitHub will not let this script arm.
+ */
+export declare const nativeStackNote: (pr: PullRequest, entry: NativeStackEntry) => Classification;
+/**
+ * Why a layer cannot be carried along when the one below it moves, or
+ * `undefined` when it can. A fork's branch is not this repository's to push
+ * to, whatever its name.
+ */
+export declare const restackable: (pr: BranchOf) => string | undefined;
+/**
+ * The pull requests this script rebases onto the default branch ahead of any
+ * turn: the bottom layer of a stack, or a lone pull request, that asked for it
+ * (`wantsAutoRebase`) and is paused by `skip-ci`, so the push costs no
+ * matrix. Whether it is actually behind is for the caller to ask
+ * git: `skip-ci` leaves the merge state at `BLOCKED` whatever the branch is.
+ * The version pull request is the release workflow's. Only the worker's own
+ * are moved (`owner.mts`): one set aside or claimed is a skill's or a
+ * person's until its comment is resolved or the claim ends.
+ */
+export declare const autoRebaseTargets: (pullRequests: readonly PullRequest[], defaultBranch: string, { owners, }: Readonly<{
+    /** Who moves each queued pull request next (`owner.mts`). */
+    owners: ReadonlyMap<number, QueueOwner>;
+}>) => readonly PullRequest[];
+/** Which open pull request each stacked one is on: child → parent. */
+export declare const stackParentsOf: (pullRequests: readonly PullRequest[], defaultBranch: string) => ReadonlyMap<number, number>;
+/**
+ * What to remember of this survey's stacks for the next one: every layer, by
+ * the branch it is on, and every layer remembered before that is still on
+ * that branch. The second is a layer whose parent has merged while GitHub
+ * has yet to move it — no open pull request heads its base any longer, so
+ * the bases alone no longer say it is a layer, but it has still to come off
+ * one.
+ */
+export declare const stackedOnAfter: (before: StackedOn | undefined, pullRequests: readonly PullRequest[], stackParents: ReadonlyMap<number, number>) => StackedOn;
+/**
+ * The pull requests the last survey saw stacked and this one sees on the
+ * default branch — before the first survey, every pull request on the
+ * default branch, whose timeline then says whether it came off a stack.
+ *
+ * A queued one is not among them: its own rebase, when it is picked, drops
+ * the merged layer's commits on its way onto the tip. Nor is anything that
+ * cannot be pushed to, or the version pull request, which was never a layer.
+ */
+export declare const retargetedLayers: (before: StackedOn | undefined, pullRequests: readonly PullRequest[], defaultBranch: string) => readonly RetargetedLayer[];
+//# sourceMappingURL=stack.d.mts.map

package/dist/unblock-prs/stack.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/stack.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,eAAe,EACf,SAAS,EACT,aAAa,EACd,MAAM,aAAa,CAAC;AAGrB;;;GAGG;AACH,eAAO,MAAM,cAAc,YAChB,SAAS,UAAU,EAAE,iBACf,MAAM,KACpB,MAAM,GAAG,SAMX,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,WAAW,OAClB,WAAW,UACP,MAAM,WACL,aAAa,KACrB,cAQU,CAAC;AAEd;;;GAGG;AACH,eAAO,MAAM,eAAe,OACtB,WAAW,SACR,gBAAgB,KACtB,cAIU,CAAC;AAEd;;;;GAIG;AACH,eAAO,MAAM,WAAW,OAAQ,QAAQ,KAAG,MAAM,GAAG,SAOjC,CAAC;AAEpB;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,iBACd,SAAS,WAAW,EAAE,iBACrB,MAAM,eAGlB,QAAQ,CAAC;IACV,6DAA6D;IAC7D,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACzC,CAAC,KACD,SAAS,WAAW,EAUpB,CAAC;AAEJ,sEAAsE;AACtE,eAAO,MAAM,cAAc,iBACX,SAAS,WAAW,EAAE,iBACrB,MAAM,KACpB,WAAW,CAAC,MAAM,EAAE,MAAM,CAS1B,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,WACjB,SAAS,GAAG,SAAS,gBACf,SAAS,WAAW,EAAE,gBACtB,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KACxC,SASA,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,WACnB,SAAS,GAAG,SAAS,gBACf,SAAS,WAAW,EAAE,iBACrB,MAAM,KACpB,SAAS,eAAe,EAiBrB,CAAC"}

package/dist/unblock-prs/stack.mjs

@@ -0,0 +1,141 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import { findStackParents, isSafeRefName, } from 'pr-report-core';
+import { isMergeQueued, isSkipCiLabelled, wantsAutoRebase } from './labels.mjs';
+import { isVersionPullRequest } from './version-pr.mjs';
+
+
+
+
+export const retargetedFrom = (changes, defaultBranch) => {
+    const last = changes.at(-1);
+    return last?.to === defaultBranch && last.from !== defaultBranch
+        ? last.from
+        : undefined;
+};
+
+export const stackedNote = (pr, parent, context) => ({
+    kind: 'note',
+    note: `#${pr.number}: stacked on #${parent}, which merges first${context.cyclic.has(pr.number)
+        ? ' — and on a cycle of stacks and Merge-After, so nothing here will move it'
+        : ''}`,
+});
+
+
+
+
+export const nativeStackNote = (pr, entry) => ({
+    kind: 'note',
+    note: `#${pr.number}: layer ${entry.position} of ${entry.size} of GitHub's native stack #${entry.stack}, on which GitHub refuses auto-merge; merge it by hand (a stack made by the base alone needs no native stack)`,
+});
+
+
+
+
+
+export const restackable = (pr) => pr.state !== 'OPEN'
+    ? `it is ${pr.state}`
+    : pr.isCrossRepository
+        ? 'its branch is in a fork'
+        : !isSafeRefName(pr.headRefName)
+            ? `branch name ${JSON.stringify(pr.headRefName)} will not be passed to a shell`
+            : undefined;
+
+
+
+
+
+
+
+
+
+
+export const autoRebaseTargets = (pullRequests, defaultBranch, { owners, }) => pullRequests.filter((pr) => pr.baseRefName === defaultBranch &&
+    !pr.isDraft &&
+    wantsAutoRebase(pr) &&
+    isSkipCiLabelled(pr) &&
+    !isVersionPullRequest(pr, defaultBranch) &&
+    restackable(pr) === undefined &&
+    owners.get(pr.number)?.owner === 'worker');
+
+export const stackParentsOf = (pullRequests, defaultBranch) => findStackParents(pullRequests.map((pr) => ({
+    number: pr.number,
+    headRef: pr.headRefName,
+    baseRef: pr.baseRefName,
+    fromFork: pr.isCrossRepository,
+})), defaultBranch);
+
+
+
+
+
+
+
+
+export const stackedOnAfter = (before, pullRequests, stackParents) => new Map(pullRequests
+    .filter((pr) => stackParents.has(pr.number) ||
+    before?.get(pr.number) === pr.baseRefName)
+    .map((pr) => [pr.number, pr.baseRefName]));
+
+
+
+
+
+
+
+
+
+export const retargetedLayers = (before, pullRequests, defaultBranch) => pullRequests
+    .filter((pr) => pr.baseRefName === defaultBranch &&
+    !isMergeQueued(pr) &&
+    !isVersionPullRequest(pr, defaultBranch) &&
+    restackable(pr) === undefined)
+    .flatMap((pr) => {
+    if (before === undefined) {
+        return [{ pr, from: undefined }];
+    }
+    const from = before.get(pr.number);
+    return from === undefined ? [] : [{ pr, from }];
+});
+//# sourceMappingURL=stack.mjs.map

package/dist/unblock-prs/stack.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.mjs","sourceRoot":"","sources":["../../src/unblock-prs/stack.mts"],"names":[],"mappings":"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"}

package/dist/unblock-prs/triage.d.mts

@@ -0,0 +1,28 @@
+/** What one survey says about each pull request, and why. */
+import { Result } from 'ts-data-forge';
+import type { StrictPick } from 'ts-type-forge';
+import { type ApiContext } from '../lib/index.mjs';
+import type { Demotions, PullRequest, Survey, Triage, TriageBase } from './types.mjs';
+/**
+ * Lists the open pull requests, re-listing a few times while GitHub is still
+ * computing a merge state (`UNKNOWN`) for one that matters.
+ */
+export declare const survey: (api: ApiContext, defaultBranch: string) => Promise<Result<Survey, string>>;
+export declare const triage: (api: ApiContext, pullRequests: readonly PullRequest[], base: TriageBase) => Promise<Triage>;
+/**
+ * The cycle's order: `pr-report-core`'s `orderCandidates`, which says why,
+ * with what this run has demoted (`demotions.mts`).
+ */
+export declare const orderCandidates: (candidates: readonly PullRequest[], context: Readonly<{
+    defaultBranch: string;
+    demoted: Demotions;
+}>) => readonly PullRequest[];
+export declare const reportTriage: (triaged: Triage, total: number, context: Readonly<{
+    defaultBranch: string;
+    demoted: Demotions;
+}>) => void;
+/** What this cycle is about to do to a pull request, as a phrase. */
+export declare const describeAction: (pr: PullRequest, defaultBranch: string, triaged: StrictPick<Triage, 'bypass' | 'stackParents' | 'toArm'>) => string;
+/** What is done instead of arming one only a bypass merges, as a phrase. */
+export declare const bypassPhrase: (reason: string | undefined) => string;
+//# sourceMappingURL=triage.d.mts.map

package/dist/unblock-prs/triage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/triage.mts"],"names":[],"mappings":"AAAA,6DAA6D;AAsB7D,OAAO,EAAiB,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAmBxE,OAAO,KAAK,EAGV,SAAS,EACT,WAAW,EACX,MAAM,EACN,MAAM,EACN,UAAU,EAEX,MAAM,aAAa,CAAC;AASrB;;;GAGG;AACH,eAAO,MAAM,MAAM,QACZ,UAAU,iBACA,MAAM,KACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8ChC,CAAC;AAoCF,eAAO,MAAM,MAAM,QACZ,UAAU,gBACD,SAAS,WAAW,EAAE,QAC9B,UAAU,KACf,OAAO,CAAC,MAAM,CAsIhB,CAAC;AA8QF;;;GAGG;AACH,eAAO,MAAM,eAAe,eACd,SAAS,WAAW,EAAE,WACzB,QAAQ,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC,KAC/D,SAAS,WAAW,EAInB,CAAC;AAEL,eAAO,MAAM,YAAY,YACd,MAAM,SACR,MAAM,WACJ,QAAQ,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC,KAC/D,IA4CF,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,cAAc,OACrB,WAAW,iBACA,MAAM,WACZ,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,KAC/D,MAmBF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,YAAY,WAAY,MAAM,GAAG,SAAS,KAAG,MAGuB,CAAC"}

package/dist/unblock-prs/triage.mjs

@@ -0,0 +1,396 @@
+
+import { asksReview, MERGE_QUEUED_LABEL, orderCandidates as orderQueueCandidates, parseCodeOwners, PRIORITY_HIGH_LABEL, PRIORITY_LOW_LABEL, queueGraph, queueStanding, reviewHold, SKIP_CI_LABEL, stackDescendants, withReviewHold, } from 'pr-report-core';
+import { Arr, isRecord, Result } from 'ts-data-forge';
+import { currentEpochMs, log } from '../lib/index.mjs';
+import { listRequiredChecks, listRunningChecks, summarizeChecks, } from './checks.mjs';
+import { UNKNOWN_STATE_RETRIES, UNKNOWN_STATE_RETRY_MS } from './constants.mjs';
+import { isDemoted } from './demotions.mjs';
+import { listPullRequests, readBranchRules, readNativeStack, readReviewStates, remoteSha, } from './github.mjs';
+import { isSkipCiLabelled, priorityOf } from './labels.mjs';
+import { waitingOnNote } from './merge-after.mjs';
+import { ownerNote, ownerOf } from './owner.mjs';
+import { nativeStackNote, stackedNote } from './stack.mjs';
+import { lastLines, pause, stopRequested } from './util.mjs';
+import { isRebuiltOnBaseTip, isVersionPullRequest, releaseBlockedNote, releaseStaleNote, } from './version-pr.mjs';
+
+
+
+
+export const survey = async (api, defaultBranch) => {
+    let mut_attempt = 0;
+    let mut_listed = await listPullRequests(api);
+    while (Result.isOk(mut_listed) &&
+        mut_attempt < UNKNOWN_STATE_RETRIES &&
+        mut_listed.value.some((pr) => pr.mergeStateStatus === 'UNKNOWN' && isRecord(pr.autoMergeRequest)) &&
+        !stopRequested()) {
+        mut_attempt += 1;
+        log(`GitHub is still computing a merge state; re-listing (${mut_attempt}/${UNKNOWN_STATE_RETRIES}).`);
+        await pause(UNKNOWN_STATE_RETRY_MS);
+        mut_listed = await listPullRequests(api);
+    }
+    if (Result.isErr(mut_listed)) {
+        return mut_listed;
+    }
+    const baseSha = await remoteSha(defaultBranch);
+    if (Result.isErr(baseSha)) {
+        return baseSha;
+    }
+    const rules = await readRules(api, defaultBranch);
+    return Result.ok({
+        pullRequests: mut_listed.value,
+        baseSha: baseSha.value,
+        requiredContexts: rules.requiredContexts,
+        reviewRequirements: {
+            requireCodeOwnerReview: rules.requireCodeOwnerReview,
+            requireConversationResolution: rules.requireConversationResolution,
+        },
+    });
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+const readRules = async (api, branch) => {
+    const rules = await readBranchRules(api, branch);
+    if (Result.isErr(rules)) {
+        log(`Cannot read the rules for ${branch}; judging by the checks that have reported, and holding nothing for review. (${lastLines(rules.value, 2)})`);
+        return {
+            requiredContexts: [],
+            requireCodeOwnerReview: false,
+            requireConversationResolution: false,
+        };
+    }
+    return rules.value;
+};
+export const triage = async (api, pullRequests, base) => {
+    const sorted = pullRequests.toSorted((a, b) => a.number - b.number);
+
+
+    const graph = queueGraph(sorted.map((pr) => ({
+        number: pr.number,
+        body: pr.body,
+        isDraft: pr.isDraft,
+        labels: pr.labels.map(({ name }) => name),
+        headRef: pr.headRefName,
+        baseRef: pr.baseRefName,
+        fromFork: pr.isCrossRepository,
+        closes: base.issueOrder.closes.get(pr.number) ?? [],
+    })), base.defaultBranch, base.issueOrder.startAfter);
+
+
+    const nowEpochMs = currentEpochMs();
+    const owners = new Map(Arr.generate(function* () {
+        for (const pr of sorted) {
+            const owner = ownerOf(pr, {
+                defaultBranch: base.defaultBranch,
+                skipped: base.skipped,
+                claimed: base.claimed,
+                stackParents: graph.stackParents,
+                cyclic: graph.cyclic,
+                nowEpochMs,
+            });
+            if (owner !== undefined) {
+                yield [pr.number, owner];
+            }
+        }
+    }));
+    const context = { ...base, ...graph, owners };
+    const beforeReview = await Promise.all(sorted.map(async (pr) => ({ pr, ...(await settle(api, pr, context)) })));
+    const holds = await readReviewHolds(api, beforeReview.filter(({ pr, standing }) => asksReview(standing, pr.mergeStateStatus)), context);
+    const classified = beforeReview.map(({ pr, standing, unread, summary }) => ({
+        pr,
+        result: unread ??
+            classification(pr, withReviewHold(standing, pr.mergeStateStatus, holds.get(pr.number)), summary, context),
+    }));
+
+
+    const bypass = new Map(Arr.generate(function* () {
+        for (const [prNumber, hold] of Array.from(holds)) {
+            if (hold.kind === 'bypass') {
+                yield [prNumber, hold.reason];
+            }
+        }
+    }));
+    return {
+        cycles: graph.cycles,
+        owners,
+        inScope: classified.filter(({ result }) => result.kind !== 'ignore').length,
+        candidates: orderCandidates(classified
+            .filter(({ result }) => result.kind === 'candidate')
+            .map(({ pr }) => pr), base),
+
+
+
+        toArm: new Set(Arr.generate(function* () {
+            for (const { pr, result } of classified) {
+                if ((result.kind === 'candidate' || result.kind === 'in-flight') &&
+                    !isRecord(pr.autoMergeRequest) &&
+                    !bypass.has(pr.number)) {
+                    yield pr.number;
+                }
+            }
+        })),
+        bypass,
+        stackParents: graph.stackParents,
+        inFlight: classified
+            .filter(({ result }) => result.kind === 'in-flight')
+            .map(({ pr }) => pr),
+        held: Arr.generate(function* () {
+            for (const { pr, result } of classified) {
+                if (result.kind === 'held') {
+                    yield `#${pr.number}: held by its review — ${result.reason}; nothing is run until that changes`;
+                }
+            }
+        }),
+        failing: Arr.generate(function* () {
+            for (const { pr, result } of classified) {
+                if (result.kind === 'failing') {
+                    yield { pr, summary: result.summary };
+                }
+            }
+        }),
+        notes: Arr.generate(function* () {
+            for (const { result } of classified) {
+                if (result.kind === 'note') {
+                    yield result.note;
+                }
+            }
+        }),
+    };
+};
+
+const factsOf = (pr) => ({
+    number: pr.number,
+    state: pr.state,
+    labels: pr.labels.map(({ name }) => name),
+    isDraft: pr.isDraft,
+    headRef: pr.headRefName,
+    baseRef: pr.baseRefName,
+    mergeState: pr.mergeStateStatus,
+    autoMerge: isRecord(pr.autoMergeRequest),
+});
+
+
+
+
+const settle = async (api, pr, context, reads = {}, summary) => {
+    const standing = queueStanding(factsOf(pr), context, reads);
+    if (standing.kind !== 'needs') {
+        return { standing, unread: undefined, summary };
+    }
+    switch (standing.read) {
+        case 'nativeStack':
+            return settle(api, pr, context, { ...reads, nativeStack: (await inNativeStack(api, pr)) ?? 'none' }, summary);
+        case 'rebuiltOnTip': {
+            const rebuilt = await isRebuiltOnBaseTip(pr, context);
+            return Result.isErr(rebuilt)
+                ? { standing, unread: rebuilt.value, summary }
+                : settle(api, pr, context, { ...reads, rebuiltOnTip: rebuilt.value }, summary);
+        }
+        case 'checksFailed': {
+            const checks = await readChecks(api, pr, context);
+            return Result.isErr(checks)
+                ? { standing, unread: checks.value, summary }
+                : settle(api, pr, context, { ...reads, checksFailed: checks.value.verdict === 'failing' }, checks.value);
+        }
+    }
+};
+
+const classification = (pr, standing, summary, context) => {
+    switch (standing.kind) {
+        case 'ignore':
+        case 'candidate':
+        case 'in-flight':
+            return { kind: standing.kind };
+        case 'held':
+            return { kind: 'held', reason: standing.reason };
+        case 'unactionable':
+            return { kind: 'note', note: `#${pr.number}: ${standing.reason}` };
+        case 'owned':
+            return (ownerNote(pr, standing.owner, context.skipped) ?? {
+                kind: 'note',
+                note: `#${pr.number}: ${standing.owner.reason}`,
+            });
+        case 'stacked':
+            return stackedNote(pr, standing.on, context);
+        case 'native-stack':
+            return nativeStackNote(pr, standing.entry);
+        case 'waiting':
+            return waitingOnNote(pr, standing.on, standing.cyclic, context.inherited.get(pr.number));
+        case 'release-blocked':
+            return releaseBlockedNote(pr, standing.by);
+        case 'release-stale':
+            return releaseStaleNote(pr, context);
+        case 'merge-state':
+            return {
+                kind: 'note',
+                note: `#${pr.number}: merge state ${standing.state}`,
+            };
+        case 'failing':
+            return summary === undefined
+                ? { kind: 'note', note: `#${pr.number}: failing` }
+                : { kind: 'failing', summary };
+        case 'needs':
+            return {
+                kind: 'note',
+                note: `#${pr.number}: could not read ${standing.read}`,
+            };
+    }
+};
+
+
+
+
+
+const inNativeStack = async (api, pr) => {
+    const entry = await readNativeStack(api, pr.number);
+    if (Result.isErr(entry)) {
+        log(`#${pr.number}: cannot read whether it is in a native stack; treating it as in none. (${lastLines(entry.value, 2)})`);
+        return undefined;
+    }
+    return entry.value;
+};
+
+
+
+
+
+
+const readReviewHolds = async (api, entries, context) => {
+    const { requireCodeOwnerReview, requireConversationResolution } = context.reviewRequirements;
+    if (!Arr.isNonEmpty(entries) ||
+        (!requireCodeOwnerReview && !requireConversationResolution)) {
+        return new Map();
+    }
+    const read = await readReviewStates(api, entries.map(({ pr }) => pr.number), context.defaultBranch);
+    if (Result.isErr(read)) {
+        log(`Cannot read the reviews; holding nothing for them. (${lastLines(read.value, 2)})`);
+        return new Map();
+    }
+    const rules = {
+        requireCodeOwnerReview,
+        requireConversationResolution,
+        codeOwners: read.value.codeOwners === undefined
+            ? []
+            : parseCodeOwners(read.value.codeOwners),
+    };
+    return new Map(Arr.generate(function* () {
+        for (const [prNumber, state] of Array.from(read.value.states)) {
+            const hold = reviewHold(state, rules);
+            if (hold !== undefined) {
+                yield [prNumber, hold];
+            }
+        }
+    }));
+};
+
+
+
+
+
+const readChecks = async (api, pr, context) => {
+    const checks = await listRequiredChecks(api, pr.number);
+    if (Result.isErr(checks)) {
+        return Result.err({
+            kind: 'note',
+            note: `#${pr.number}: could not read checks: ${checks.value}`,
+        });
+    }
+
+
+
+    const running = await listRunningChecks(api, pr.number);
+    if (Result.isErr(running)) {
+        return Result.err({
+            kind: 'note',
+            note: `#${pr.number}: could not read checks: ${running.value}`,
+        });
+    }
+    return Result.ok(summarizeChecks(checks.value, context.requiredContexts, running.value));
+};
+
+
+
+
+
+const isConflicting = (pr) => pr.mergeStateStatus === 'DIRTY';
+
+
+
+
+export const orderCandidates = (candidates, context) => orderQueueCandidates(candidates, factsOf, {
+    defaultBranch: context.defaultBranch,
+    demoted: (pr) => isDemoted(context.demoted, pr),
+});
+export const reportTriage = (triaged, total, context) => {
+    const { defaultBranch } = context;
+    const paused = triaged.candidates.filter(isSkipCiLabelled).length;
+    log(`${total} open pull request(s), ${triaged.inScope} labelled ${MERGE_QUEUED_LABEL}: ${triaged.candidates.length} to act on (${paused} paused by ${SKIP_CI_LABEL}), ${triaged.inFlight.length} in flight, ${triaged.failing.length} failing, ${triaged.held.length} held by review.`);
+    for (const cycle of triaged.cycles) {
+        if (!Arr.isNonEmpty(cycle)) {
+            continue;
+        }
+        log(`  Merge-After cycle: ${[...cycle, cycle[0]].map((number) => `#${number}`).join(' → ')}`);
+    }
+    for (const held of triaged.held) {
+        log(`  ${held}`);
+    }
+    for (const [prNumber, reason] of triaged.bypass) {
+        log(`  #${prNumber}: only a ruleset bypass merges it — ${reason}; its checks are run, and auto-merge is left off`);
+    }
+    for (const note of triaged.notes) {
+        log(`  ${note}`);
+    }
+    for (const { pr, summary } of triaged.failing) {
+        log(`  #${pr.number}: up to date but failing: ${summary.failed.join(', ')}`);
+    }
+    for (const [position, pr] of triaged.candidates.entries()) {
+        log(`  #${pr.number}: ${position === 0 ? 'next' : `${position} ahead of it`} — ${describeAction(pr, defaultBranch, triaged)}${isDemoted(context.demoted, pr) ? ' — last, because it sat green without merging' : ''}${priorityPhrase(pr)} — ${pr.title}`);
+    }
+};
+
+export const describeAction = (pr, defaultBranch, triaged) => {
+    if (isVersionPullRequest(pr, defaultBranch)) {
+        return `take ${SKIP_CI_LABEL} off it — the release workflow owns the branch`;
+    }
+    const above = stackDescendants(triaged.stackParents, pr.number);
+    return [
+        `rebase onto ${defaultBranch}`,
+        isConflicting(pr)
+            ? ', which GitHub says conflicts — a rebase will say'
+            : '',
+        Arr.isNonEmpty(above)
+            ? `, carry ${above.map((n) => `#${n}`).join(', ')} stacked on it along`
+            : '',
+        triaged.toArm.has(pr.number) ? ', arm auto-merge' : '',
+        bypassPhrase(triaged.bypass.get(pr.number)),
+        isSkipCiLabelled(pr) ? `, then take ${SKIP_CI_LABEL} off it` : '',
+    ].join('');
+};
+
+export const bypassPhrase = (reason) => reason === undefined
+    ? ''
+    : `, leave auto-merge off (${reason}, so it needs a bypass merge)`;
+
+const priorityPhrase = (pr) => {
+    switch (priorityOf(pr)) {
+        case 'high':
+            return ` — ahead of the rest, by ${PRIORITY_HIGH_LABEL}`;
+        case 'low':
+            return ` — behind the rest, by ${PRIORITY_LOW_LABEL}`;
+        case 'both':
+            return ` — labelled both ${PRIORITY_HIGH_LABEL} and ${PRIORITY_LOW_LABEL}, so neither counts`;
+        case 'none':
+            return '';
+    }
+};
+//# sourceMappingURL=triage.mjs.map