pr-report-core 0.2.0 → 0.3.0

package/src/merge-after.mts

@@ -8,11 +8,10 @@ import { Arr, Num, Result } from 'ts-data-forge';
 
 /**
  * `#N`, and only when nothing that could end a repository name comes right
- * before the `#`: `other/repo#5` is another repository's #5, and treating it
- * as this one's would wait for a pull request the author never named.
- * `noshiro-pf/mono#5` is not read either, though it means this repository —
- * the declaration takes `#N` and nothing else, so there is one way to write
- * it.
+ * before the `#`: `other/repo#5` is another repository's #5, and treating it as
+ * this one's would wait for a pull request the author never named.
+ * `noshiro-pf/mono#5` is not read either, though it means this repository — the
+ * declaration takes `#N` and nothing else, so there is one way to write it.
  */
 const NUMBER_REF = /(?<![\w./-])#(?<number>\d+)\b/gu;
 
@@ -21,53 +20,84 @@ const DECLARATION_LINE = {
   'start-after': /^[^\S\n]*start-after[^\S\n]*:(?<refs>[^\n]*)$/gimu,
 } as const;
 
-/** The opening or closing line of a fenced code block. */
-const FENCE_LINE = /^[^\S\n]*(?:`{3,}|~{3,})/u;
+/**
+ * A line that can open or close a fenced code block: a run of three or more
+ * backticks or tildes, and what follows it on the line.
+ */
+const FENCE_LINE = /^[^\S\n]*(?<marker>`{3,}|~{3,})(?<rest>[^\n]*)$/u;
 
 /**
  * The pull request numbers a body declares this one must merge after.
  *
  * Duplicates are dropped and the order within the declaration is not kept:
  * what is being read is a set of things that have to have happened, not a
- * sequence. A number that names no pull request, or one that is already
- * closed, simply never appears in the open list and so constrains nothing.
+ * sequence. A number that names no pull request, or one that is already closed,
+ * simply never appears in the open list and so constrains nothing.
  */
 export const parseMergeAfter = (body: string): readonly number[] =>
   parseDeclaration(body, 'merge-after');
 
 /**
- * The numbers an issue body declares it waits for before it is started,
- * read exactly as {@link parseMergeAfter} reads its trailer
+ * The numbers an issue body declares it waits for before it is started, read
+ * exactly as {@link parseMergeAfter} reads its trailer
  * (`docs/issue-start-after.md`).
  */
 export const parseStartAfter = (body: string): readonly number[] =>
   parseDeclaration(body, 'start-after');
 
 /**
- * The body with the contents of its fenced code blocks blanked out, line
- * count preserved.
+ * The body with the contents of its fenced code blocks blanked out, line count
+ * preserved.
  *
  * A declaration and an example of one are the same text, and the pull request
  * that introduced this feature had to describe it: written in a fence, the
- * example would have been read as a constraint on the pull request
- * documenting it. A fence is how every document here already says "this is a
- * sample, not the thing itself", so it is the line to draw.
+ * example would have been read as a constraint on the pull request documenting
+ * it. A fence is how every document here already says "this is a sample, not
+ * the thing itself", so it is the line to draw.
  *
- * Exported because `pr-report` reads the closing keywords (`Closes #12`) out
- * of the same bodies and has to draw the line in the same place — a document
+ * Exported because `pr-report` reads the closing keywords (`Closes #12`) out of
+ * the same bodies and has to draw the line in the same place — a document
  * showing what a declaration looks like must not become one.
  */
 export const outsideCodeFences = (body: string): string => {
-  let mut_inFence = false;
+  // The marker that opened the fence the current line is in, if any.
+  let mut_openedBy: string | undefined = undefined;
 
   return body
     .split('\n')
     .map((line) => {
-      if (!FENCE_LINE.test(line)) {
-        return mut_inFence ? '' : line;
+      const fence = FENCE_LINE.exec(line)?.groups;
+
+      const marker = fence?.['marker'];
+
+      const rest = fence?.['rest'] ?? '';
+
+      if (mut_openedBy === undefined) {
+        // A backtick fence's info string cannot hold a backtick (CommonMark),
+        // so ```` ```x``` ```` is inline code, not an opening line.
+        if (
+          marker === undefined ||
+          (marker.startsWith('`') && rest.includes('`'))
+        ) {
+          return line;
+        }
+
+        mut_openedBy = marker;
+
+        return '';
       }
 
-      mut_inFence = !mut_inFence;
+      // Only a run of the opening character, at least as long, with nothing
+      // after it, closes the fence (CommonMark); any other fence line is part
+      // of the code, so a ``` inside a ```` or ~~~ block does not end it.
+      if (
+        marker !== undefined &&
+        marker.at(0) === mut_openedBy.at(0) &&
+        marker.length >= mut_openedBy.length &&
+        rest.trim() === ''
+      ) {
+        mut_openedBy = undefined;
+      }
 
       return '';
     })
@@ -75,52 +105,50 @@ export const outsideCodeFences = (body: string): string => {
 };
 
 /**
- * The `Merge-After` cycles, one entry per cycle, each listing the numbers in
- * the order the edges run and rotated to start at its lowest number so that
- * the same cycle is always reported the same way.
+ * The `Merge-After` cycles, each listing the numbers in the order the edges run
+ * and rotated to start at its lowest number so that the same cycle is always
+ * reported the same way.
+ *
+ * Every number that lies on any cycle appears in at least one entry — callers
+ * take `cycles.flat()` as the set of numbers on a cycle. Each entry is the
+ * shortest cycle through the first number, in key order, that no earlier entry
+ * covers, so a component with several loops yields one entry per loop needed to
+ * cover it rather than every loop it holds.
  *
  * A cycle is not a state anything here can resolve: every pull request on one
  * waits for another that waits, in the end, for it. Naming it is the whole of
  * what can be done about it — without this the members would each report
  * "waiting on #N" for as long as the loop runs, with nothing saying why that
- * never changes. A pull request that declares itself is a cycle of one, and
- * is found by the same walk.
+ * never changes. A pull request that declares itself is a cycle of one, and is
+ * found by the same search.
  */
 export const findMergeAfterCycles = (
   dependencies: ReadonlyMap<number, readonly number[]>,
 ): readonly (readonly number[])[] => {
-  const mut_finished = new Set<number>();
+  const mut_covered = new Set<number>();
 
   const mut_cycles = new Map<string, readonly number[]>();
 
-  const visit = (node: number, walked: readonly number[]): void => {
-    const at = walked.indexOf(node);
-
-    if (at !== -1) {
-      // A back edge into the path being walked: everything from there on is
-      // the cycle.
-      const cycle = rotateToLowest(walked.slice(at));
-
-      mut_cycles.set(cycle.join(','), cycle);
-
-      return;
+  for (const node of dependencies.keys()) {
+    if (mut_covered.has(node)) {
+      continue;
     }
 
-    if (mut_finished.has(node)) {
-      return;
+    // A search per node rather than one depth-first walk: a walk that skips
+    // finished nodes misses a node whose only way back runs through one.
+    const cycle = shortestCycleThrough(node, dependencies);
+
+    if (cycle === undefined) {
+      continue;
     }
 
-    for (const dependency of dependencies.get(node) ?? []) {
-      visit(dependency, Arr.toPushed(walked, node));
+    for (const member of cycle) {
+      mut_covered.add(member);
     }
 
-    // Only once every edge out of it has been walked, so no back edge into
-    // this node's subtree can be missed by the walk that comes next.
-    mut_finished.add(node);
-  };
+    const rotated = rotateToLowest(cycle);
 
-  for (const node of dependencies.keys()) {
-    visit(node, []);
+    mut_cycles.set(rotated.join(','), rotated);
   }
 
   return Array.from(mut_cycles.values());
@@ -149,6 +177,71 @@ const parseDeclaration = (
       .toArray(),
   );
 
+/** `start`, …, `end`, following `reachedFrom` back from `end`. */
+const pathFromStart = (
+  start: number,
+  end: number,
+  reachedFrom: ReadonlyMap<number, number>,
+): readonly number[] => {
+  const mut_reversed: number[] = [end];
+
+  let mut_node = end;
+
+  while (mut_node !== start) {
+    const previous = reachedFrom.get(mut_node);
+
+    if (previous === undefined) {
+      break;
+    }
+
+    mut_reversed.push(previous);
+
+    mut_node = previous;
+  }
+
+  return mut_reversed.toReversed();
+};
+
+/**
+ * The shortest cycle through `start`, from `start` along the edges back to the
+ * node whose edge returns to it, or `undefined` when no path leads back.
+ */
+const shortestCycleThrough = (
+  start: number,
+  dependencies: ReadonlyMap<number, readonly number[]>,
+): readonly number[] | undefined => {
+  // Each reached node, with the node it was first reached from.
+  const mut_reachedFrom = new Map<number, number>();
+
+  // Level by level: every node in the frontier is one edge further from `start`
+  // than the last, so the first edge back to `start` closes a shortest cycle.
+  let mut_frontier: readonly number[] = [start];
+
+  while (Arr.isNonEmpty(mut_frontier)) {
+    const mut_nextFrontier: number[] = [];
+
+    for (const node of mut_frontier) {
+      for (const next of dependencies.get(node) ?? []) {
+        if (next === start) {
+          return pathFromStart(start, node, mut_reachedFrom);
+        }
+
+        if (mut_reachedFrom.has(next)) {
+          continue;
+        }
+
+        mut_reachedFrom.set(next, node);
+
+        mut_nextFrontier.push(next);
+      }
+    }
+
+    mut_frontier = mut_nextFrontier;
+  }
+
+  return undefined;
+};
+
 const rotateToLowest = (cycle: readonly number[]): readonly number[] => {
   if (!Arr.isNonEmpty(cycle)) {
     return cycle;

package/src/merge-after.test.mts

@@ -51,9 +51,9 @@ describe(parseMergeAfter, () => {
     );
   });
 
-  // The fence markers and the column they sit in are what these two are
-  // about, so the fixtures are arrays of lines rather than a template
-  // literal: what `dedent` would remove is what is being tested.
+  // The fence markers and the column they sit in are what these two are about,
+  // so the fixtures are arrays of lines rather than a template literal: what
+  // `dedent` would remove is what is being tested.
   test('ignores a trailer inside a fenced code block', () => {
     assert.deepStrictEqual(
       parseMergeAfter(
@@ -79,6 +79,64 @@ describe(parseMergeAfter, () => {
     );
   });
 
+  test('ignores the trailers inside a longer fence that holds a shorter one', () => {
+    assert.deepStrictEqual(
+      parseMergeAfter(
+        [
+          '````markdown',
+          '```',
+          'Merge-After: #1901',
+          '```',
+          'Merge-After: #1902',
+          '````',
+          'Merge-After: #1903',
+          '',
+        ].join('\n'),
+      ),
+      [1903],
+    );
+  });
+
+  test('ignores a trailer after a backtick fence inside a tilde fence', () => {
+    assert.deepStrictEqual(
+      parseMergeAfter(
+        ['~~~', '```', 'Merge-After: #1901', '~~~', ''].join('\n'),
+      ),
+      [],
+    );
+  });
+
+  test('does not close a fence on a line with an info string', () => {
+    assert.deepStrictEqual(
+      parseMergeAfter(
+        ['```', '```ts', 'Merge-After: #1901', '```', ''].join('\n'),
+      ),
+      [],
+    );
+  });
+
+  test('closes a fence on a longer run of the same character', () => {
+    assert.deepStrictEqual(
+      parseMergeAfter(
+        ['```', 'Merge-After: #1901', '`````', 'Merge-After: #1903', ''].join(
+          '\n',
+        ),
+      ),
+      [1903],
+    );
+  });
+
+  test('closes a fence on a CRLF line', () => {
+    assert.deepStrictEqual(
+      parseMergeAfter(
+        ['```', 'Merge-After: #1901', '```', 'Merge-After: #1903', ''].join(
+          '\r\n',
+        ),
+      ),
+      [1903],
+    );
+  });
+
   test('reads a body with the CRLF line endings GitHub returns', () => {
     assert.deepStrictEqual(
       parseMergeAfter('Adds the parser.\r\n\r\nMerge-After: #1901\r\n'),
@@ -218,6 +276,25 @@ describe(findMergeAfterCycles, () => {
     );
   });
 
+  test('reports a member whose only way back runs through a finished node', () => {
+    // 3 → 2 → 1 → 3 is a cycle as well as 1 ⇄ 2; a walk from 1 finishes 2
+    // before it reaches 3, so 3's edge into 2 must still put 3 on a cycle.
+    const cycles = findMergeAfterCycles(
+      new Map<number, readonly number[]>([
+        [1, [2, 3]],
+        [2, [1]],
+        [3, [2]],
+      ]),
+    );
+
+    assert.deepStrictEqual(cycles, [
+      [1, 2],
+      [1, 3, 2],
+    ]);
+
+    assert.deepStrictEqual(new Set(cycles.flat()), new Set<number>([1, 2, 3]));
+  });
+
   test('follows an edge to a pull request that declared nothing', () => {
     assert.deepStrictEqual(
       findMergeAfterCycles(new Map<number, readonly number[]>([[1, [2]]])),

package/src/queue-comments.mts

@@ -41,8 +41,8 @@ export type QueueComment<A> = Readonly<{
 }>;
 
 /**
- * Reads `comments`, oldest first, for the oldest comment of each kind: each
- * is one comment edited in place, and of several the oldest is the one.
+ * Reads `comments`, oldest first, for the oldest comment of each kind: each is
+ * one comment edited in place, and of several the oldest is the one.
  */
 export const readQueueComments = (
   comments: readonly OwnComment[],

package/src/queue-order.mts

@@ -2,13 +2,13 @@
  * Where each pull request stands in `unblock-prs`'s queue, and the order the
  * worker picks the ones it may pick.
  *
- * The worker decides on someone's machine, from what `gh` and `git` return,
- * and the Pull Requests Manager page draws the same queue from what GraphQL
+ * The worker decides on someone's machine, from what `gh` and `git` return, and
+ * the Pull Requests Manager page draws the same queue from what GraphQL
  * returns. So the deciding is here, once, over facts either side can supply,
  * and each side does only its own reading: the worker reads some facts only
  * when the answer needs them — the checks of a `BLOCKED` pull request, the
- * native stack of one without auto-merge — which is why
- * {@link queueStanding} asks for them rather than taking them all up front.
+ * native stack of one without auto-merge — which is why {@link queueStanding}
+ * asks for them rather than taking them all up front.
  *
  * What the worker alone knows is left out: which pull requests one run has
  * demoted (`demotions.mts` in `unblock-prs`) lives in that run's memory, so
@@ -39,8 +39,8 @@ export type QueueFacts = Readonly<{
   headRef: string;
   baseRef: string;
   /**
-   * GitHub's `mergeStateStatus` — `BEHIND`, `DIRTY`, `CLEAN`, `BLOCKED` and
-   * so on — or as near to it as the reader can tell.
+   * GitHub's `mergeStateStatus` — `BEHIND`, `DIRTY`, `CLEAN`, `BLOCKED` and so
+   * on — or as near to it as the reader can tell.
    */
   mergeState: string;
   autoMerge: boolean;
@@ -57,8 +57,8 @@ export type QueueGraphMember = Readonly<{
   baseRef: string;
   fromFork: boolean;
   /**
-   * The open issues it closes, whose `Start-After:` it inherits. Absent for
-   * a reader that did not read them: nothing is inherited.
+   * The open issues it closes, whose `Start-After:` it inherits. Absent for a
+   * reader that did not read them: nothing is inherited.
    */
   closes?: readonly number[];
 }>;
@@ -68,8 +68,8 @@ export type QueueGraph = Readonly<{
   /** Which open pull request each stacked one is on: child → parent. */
   stackParents: ReadonlyMap<number, number>;
   /**
-   * What each pull request must merge after: what it declared, the one it
-   * is stacked on, and what it inherits.
+   * What each pull request must merge after: what it declared, the one it is
+   * stacked on, and what it inherits.
    */
   dependencies: ReadonlyMap<number, readonly number[]>;
   /**
@@ -165,9 +165,9 @@ export const versionBranchName = (defaultBranch: string): string =>
   `changeset-release/${defaultBranch}` as const;
 
 /**
- * Whether a pull request from `headRef` is the version pull request. The
- * branch is the only stable handle on it: the title and body are rewritten
- * on every run, and the number changes with every release.
+ * Whether a pull request from `headRef` is the version pull request. The branch
+ * is the only stable handle on it: the title and body are rewritten on every
+ * run, and the number changes with every release.
  */
 export const isVersionBranch = (
   headRef: string,
@@ -191,8 +191,8 @@ export const isMergeableState = (mergeState: string): boolean =>
 
 /**
  * The stacks, the declared order and its cycles, and what holds the release,
- * read off the open pull requests. `startAfterOf` is what the issues they
- * close declare, each issue's `Start-After:` by its number.
+ * read off the open pull requests. `startAfterOf` is what the issues they close
+ * declare, each issue's `Start-After:` by its number.
  */
 export const queueGraph = (
   pulls: readonly QueueGraphMember[],
@@ -219,12 +219,12 @@ export const queueGraph = (
 
       return [
         pr.number,
-        // The version pull request declares nothing: its body is rewritten
-        // on every push to the base, so a trailer written there would hold
-        // for a cycle or two and then silently stop. `blocks-release`, on
-        // the pull requests it is waiting for, is how an order is declared
-        // on it. Other pull requests may still name *it*. A stacked pull
-        // request waits for the layer below it whether or not it says so.
+        // The version pull request declares nothing: its body is rewritten on
+        // every push to the base, so a trailer written there would hold for a
+        // cycle or two and then silently stop. `blocks-release`, on the pull
+        // requests it is waiting for, is how an order is declared on it. Other
+        // pull requests may still name *it*. A stacked pull request waits for
+        // the layer below it whether or not it says so.
         isVersionBranch(pr.headRef, defaultBranch)
           ? []
           : Arr.uniq([
@@ -241,8 +241,8 @@ export const queueGraph = (
 
       return [
         number,
-        // The version pull request closes nothing it means to, and is held
-        // by `blocks-release` alone.
+        // The version pull request closes nothing it means to, and is held by
+        // `blocks-release` alone.
         isVersionBranch(headRef, defaultBranch)
           ? []
           : (inheritedOrders.get(number)?.mergeAfter ?? []).filter(
@@ -288,15 +288,15 @@ export const queueStanding = (
   if (outOfScope !== undefined) {
     // `merge-queued` is an explicit request, so anything that answers it with
     // "no" is worth saying out loud — a queued pull request left as a draft
-    // would otherwise sit in the queue forever with nothing saying why. A
-    // pull request that never asked is passed over in silence.
+    // would otherwise sit in the queue forever with nothing saying why. A pull
+    // request that never asked is passed over in silence.
     return hasLabel(pr, MERGE_QUEUED_LABEL)
       ? { kind: 'unactionable', reason: outOfScope }
       : { kind: 'ignore' };
   }
 
-  // A pull request set aside, or claimed, is a skill's or a person's until
-  // its comment is resolved (`queue-owner.mts`).
+  // A pull request set aside, or claimed, is a skill's or a person's until its
+  // comment is resolved (`queue-owner.mts`).
   const owner = context.owners.get(pr.number);
 
   if (owner !== undefined && owner.owner !== 'worker') {
@@ -327,9 +327,9 @@ export const queueStanding = (
     }
   }
 
-  // The version pull request is rebuilt from the tip of the base by the
-  // release workflow, never rebased here; taking `skip-ci` off is the whole
-  // of what it can be given.
+  // The version pull request is rebuilt from the tip of the base by the release
+  // workflow, never rebased here; taking `skip-ci` off is the whole of what it
+  // can be given.
   if (isVersionBranch(pr.headRef, context.defaultBranch)) {
     return versionStanding(pr, context, reads);
   }
@@ -342,9 +342,9 @@ export const queueStanding = (
   }
 
   switch (pr.mergeState) {
-    // `DIRTY` is a candidate too: it answers whether *merging* conflicts,
-    // from a cached computation, where the worker *rebases*, and the rebase
-    // is what says whether the conflict is real.
+    // `DIRTY` is a candidate too: it answers whether *merging* conflicts, from
+    // a cached computation, where the worker *rebases*, and the rebase is what
+    // says whether the conflict is real.
     case 'BEHIND':
     case 'DIRTY':
       return waitingOn(pr, context) ?? { kind: 'candidate' };
@@ -363,10 +363,10 @@ export const queueStanding = (
 };
 
 /**
- * Whether what {@link queueStanding} decided is worth asking the review
- * about: one about to be picked, or one about to be watched while GitHub
- * still calls it `BLOCKED`. A merge state GitHub already calls mergeable is
- * its own answer that nothing but the checks is left.
+ * Whether what {@link queueStanding} decided is worth asking the review about:
+ * one about to be picked, or one about to be watched while GitHub still calls
+ * it `BLOCKED`. A merge state GitHub already calls mergeable is its own answer
+ * that nothing but the checks is left.
  */
 export const asksReview = (
   standing: QueueStanding,
@@ -377,8 +377,8 @@ export const asksReview = (
 
 /**
  * The standing once the review is known: a hold that waits for someone holds
- * it; one that only a bypass merges, and none at all, change nothing here —
- * the worker leaves the first unarmed, which is not a question of order.
+ * it; one that only a bypass merges, and none at all, change nothing here — the
+ * worker leaves the first unarmed, which is not a question of order.
  */
 export const withReviewHold = (
   standing: QueueStanding,
@@ -392,9 +392,9 @@ export const withReviewHold = (
 export type QueuePriority = 'high' | 'low' | 'none' | 'both';
 
 /**
- * Which priority label a pull request carries: `both` is the two at once,
- * which contradict each other and so count as neither. `priority:mid` is the
- * same as neither here.
+ * Which priority label a pull request carries: `both` is the two at once, which
+ * contradict each other and so count as neither. `priority:mid` is the same as
+ * neither here.
  */
 export const priorityOfLabels = (labels: readonly string[]): QueuePriority => {
   const high = labels.includes(PRIORITY_HIGH_LABEL);
@@ -427,9 +427,9 @@ export const priorityRankOfLabels = (labels: readonly string[]): 0 | 1 | 2 => {
  * ruleset bypass merges ({@link ReviewHold}): that one ranks with
  * `priority:low` unless labelled `priority:high` — alone, since the two
  * together count as neither. Picked, it is released, goes green and is set
- * aside for a person, so the cycle spent on it lands nothing; picked last,
- * it still has its checks run. `priority:high` is a person saying they want
- * that verdict now, and is the one way to ask for it, so it still counts.
+ * aside for a person, so the cycle spent on it lands nothing; picked last, it
+ * still has its checks run. `priority:high` is a person saying they want that
+ * verdict now, and is the one way to ask for it, so it still counts.
  */
 export const pickPriorityRank = (
   labels: readonly string[],
@@ -443,9 +443,9 @@ export const pickPriorityRank = (
 };
 
 /**
- * The order the worker picks candidates in. The declared order has already
- * been applied, as a gate rather than a sort, so this is lowest number first
- * within these ranks, outermost first:
+ * The order the worker picks candidates in. The declared order has already been
+ * applied, as a gate rather than a sort, so this is lowest number first within
+ * these ranks, outermost first:
  *
  * 1. What a watch has seen green and still open (`demoted`) goes after
  *    everything else, the release and `priority:high` included: everything
@@ -463,8 +463,8 @@ export const pickPriorityRank = (
  *    release: it only says that when a queued change and the release are
  *    both ready, the change goes first.
  *
- * `toSorted` is stable, so each sort keeps the order of the one before it
- * among equals, and the last one is the outermost.
+ * `toSorted` is stable, so each sort keeps the order of the one before it among
+ * equals, and the last one is the outermost.
  */
 export const orderCandidates = <P,>(
   candidates: readonly P[],
@@ -498,9 +498,8 @@ export const orderCandidates = <P,>(
 };
 
 /**
- * Whether `pr` carries the label `name`. A function rather than `includes`
- * in place, which narrows the label constant itself to `never` where it says
- * no.
+ * Whether `pr` carries the label `name`. A function rather than `includes` in
+ * place, which narrows the label constant itself to `never` where it says no.
  */
 const hasLabel = (
   pr: Readonly<{ labels: readonly string[] }>,
@@ -522,10 +521,9 @@ const outOfScopeReason = (
     return `not labelled ${MERGE_QUEUED_LABEL}`;
   }
 
-  // A base that is neither the default branch nor another open pull
-  // request's branch is one nothing here knows how to land on. A stacked one
-  // whose parent has just merged reads this way for the moment before GitHub
-  // moves it.
+  // A base that is neither the default branch nor another open pull request's
+  // branch is one nothing here knows how to land on. A stacked one whose parent
+  // has just merged reads this way for the moment before GitHub moves it.
   return pr.isDraft
     ? 'draft'
     : pr.baseRef !== context.defaultBranch &&
@@ -565,17 +563,17 @@ const byChecks = (reads: QueueReads): QueueStanding =>
       : ({ kind: 'in-flight' } as const);
 
 /**
- * The version pull request: held while anything labelled `blocks-release`
- * is open, and while the branch was built before the tip of the base, then
- * a candidate if paused and otherwise judged by its checks.
+ * The version pull request: held while anything labelled `blocks-release` is
+ * open, and while the branch was built before the tip of the base, then a
+ * candidate if paused and otherwise judged by its checks.
  */
 const versionStanding = (
   pr: QueueFacts,
   context: QueueContext,
   reads: QueueReads,
 ): QueueStanding => {
-  // Never one of its own blockers: the label on it would otherwise hold it
-  // for as long as it existed.
+  // Never one of its own blockers: the label on it would otherwise hold it for
+  // as long as it existed.
   const by = context.releaseBlockers.filter(
     (blocker) => blocker.number !== pr.number,
   );