pr-report-core 0.2.0 → 0.2.1

package/src/closing-issues.test.mts

@@ -145,8 +145,8 @@ describe(closingKeywordIssuesIn, () => {
 });
 
 /**
- * A reference as GitHub renders it in a pull request's `bodyHTML`, with
- * the attributes in the order GitHub writes them.
+ * A reference as GitHub renders it in a pull request's `bodyHTML`, with the
+ * attributes in the order GitHub writes them.
  */
 const link = (
   nameWithOwner: string,

package/src/code-owners.mts

@@ -3,18 +3,18 @@
  *
  * Read because GitHub will not say. `main`'s ruleset has
  * `require_code_owner_review` on, so a pull request touching an owned path
- * waits for an owner to approve it — and nothing on a pull request reports
- * that wait: `reviewDecision` answers `null` for every pull request here,
- * owned paths or not, because it describes branch protection rather than a
- * ruleset. So it is worked out the way GitHub does, from the file — by the
- * Pull Requests Manager page, to show the wait, and by `unblock-prs`, to
- * leave a pull request that waits in the queue rather than run its checks.
+ * waits for an owner to approve it — and nothing on a pull request reports that
+ * wait: `reviewDecision` answers `null` for every pull request here, owned
+ * paths or not, because it describes branch protection rather than a ruleset.
+ * So it is worked out the way GitHub does, from the file — by the
+ * Pull Requests Manager page, to show the wait, and by `unblock-prs`, to leave
+ * a pull request that waits in the queue rather than run its checks.
  *
- * The patterns are the subset of `.gitignore` syntax GitHub documents for
- * this file: a leading `/` or a `/` in the middle anchors a pattern to the
- * root, a trailing `/` makes it a directory, `*` and `?` stay inside one path
- * segment and `**` crosses them. Negation and character ranges are not
- * supported by GitHub here either.
+ * The patterns are the subset of `.gitignore` syntax GitHub documents for this
+ * file: a leading `/` or a `/` in the middle anchors a pattern to the root, a
+ * trailing `/` makes it a directory, `*` and `?` stay inside one path segment
+ * and `**` crosses them. Negation and character ranges are not supported by
+ * GitHub here either.
  */
 
 import { Arr } from 'ts-data-forge';
@@ -22,8 +22,8 @@ import { Arr } from 'ts-data-forge';
 export type CodeOwnersRule = Readonly<{
   pattern: string;
   /**
-   * Without the leading `@`. Empty for a pattern that clears the owners of
-   * what an earlier line matched.
+   * Without the leading `@`. Empty for a pattern that clears the owners of what
+   * an earlier line matched.
    */
   owners: readonly string[];
 }>;
@@ -45,9 +45,9 @@ export const parseCodeOwners = (text: string): readonly CodeOwnersRule[] =>
   });
 
 /**
- * The owners of one path: those of the **last** pattern that matches it,
- * which is how GitHub reads the file — a later line overrides an earlier one
- * rather than adding to it.
+ * The owners of one path: those of the **last** pattern that matches it, which
+ * is how GitHub reads the file — a later line overrides an earlier one rather
+ * than adding to it.
  */
 export const ownersOf = (
   path: string,
@@ -57,19 +57,18 @@ export const ownersOf = (
 
 /**
  * What GitHub would say, worked out the way GitHub does: every changed path
- * that has owners needs an approval from one of them. An approval is the
- * latest review of an owner that says so; one dismissed by a later push —
- * the ruleset dismisses stale approvals — no longer counts, and GitHub has
- * already stopped calling it an approval by the time this reads it.
+ * that has owners needs an approval from one of them. An approval is the latest
+ * review of an owner that says so; one dismissed by a later push — the ruleset
+ * dismisses stale approvals — no longer counts, and GitHub has already stopped
+ * calling it an approval by the time this reads it.
  *
- * Owners are compared by login, case-insensitively, as GitHub compares
- * them. A team owner (`@org/team`) cannot be: telling who is on the team
- * takes `read:org`, which neither reader asks for. So a path a team owns
- * waits while nobody at all has approved, is approved by a person owning it
- * beside the team, and otherwise — someone approved, and might be on the
- * team — cannot be told, which makes the whole `unknown` unless another
- * path is plainly still waiting. `CODEOWNERS` in this repository names no
- * team.
+ * Owners are compared by login, case-insensitively, as GitHub compares them. A
+ * team owner (`@org/team`) cannot be: telling who is on the team takes
+ * `read:org`, which neither reader asks for. So a path a team owns waits while
+ * nobody at all has approved, is approved by a person owning it beside the
+ * team, and otherwise — someone approved, and might be on the team — cannot be
+ * told, which makes the whole `unknown` unless another path is plainly still
+ * waiting. `CODEOWNERS` in this repository names no team.
  */
 export const codeOwnerReview = ({
   required,
@@ -150,8 +149,8 @@ const stripComment = (line: string): string => {
   return at === -1 ? line : line.slice(0, at);
 };
 
-// Not `RegExp.escape`: it arrived in Node 24, and `ws:check:test` also runs
-// on the `engines.node` floor (`test-node-versions (minimum)`), which is 22.
+// Not `RegExp.escape`: it arrived in Node 24, and `ws:check:test` also runs on
+// the `engines.node` floor (`test-node-versions (minimum)`), which is 22.
 // Under the `u` flag only the syntax characters and `/` may be escaped, and
 // everything else is a literal as it stands.
 const escapeChar = (char: string): string =>
@@ -187,11 +186,10 @@ const toRegExp = (pattern: string): RegExp => {
 
   const body = globToRegExpSource(trimmed);
 
-  // A directory owns what is under it and never matches as a file. A name
-  // with no trailing slash may be either, so it matches itself and what is
-  // under it — unless its last segment is a wildcard, which GitHub reads as
-  // files at that level only: `docs/*` owns `docs/a.md` and not
-  // `docs/build/a.md`.
+  // A directory owns what is under it and never matches as a file. A name with
+  // no trailing slash may be either, so it matches itself and what is under it
+  // — unless its last segment is a wildcard, which GitHub reads as files at
+  // that level only: `docs/*` owns `docs/a.md` and not `docs/build/a.md`.
   const tail = directory
     ? '/.+'
     : (trimmed.split('/').at(-1) ?? '').includes('*')
@@ -206,12 +204,12 @@ const toRegExp = (pattern: string): RegExp => {
  * Where a pull request stands with the code owners.
  *
  * `required` lists what is still waiting — the owned paths no owner has
- * approved yet, and who could approve them. `authorOwns` is the case that
- * waits for ever: GitHub does not let an author approve their own pull
- * request, so when the author is the only owner nothing but a ruleset bypass
- * will merge it. `unknown` is a pull request whose changed files were more
- * than could be read, where the unread ones might be owned — or, with
- * `teams`, one approved by someone these teams might have as a member.
+ * approved yet, and who could approve them. `authorOwns` is the case that waits
+ * for ever: GitHub does not let an author approve their own pull request, so
+ * when the author is the only owner nothing but a ruleset bypass will merge it.
+ * `unknown` is a pull request whose changed files were more than could be read,
+ * where the unread ones might be owned — or, with `teams`, one approved by
+ * someone these teams might have as a member.
  */
 export type CodeOwnerReview = Readonly<
   | { state: 'approved' }

package/src/labels.mts

@@ -1,23 +1,23 @@
 /**
- * The labels this repository's queue is made of. They exist only on GitHub,
- * so these strings, and the ones in `.github/workflows/`, are the whole of
- * their declaration: `unblock-prs` and `open-pr` act on them, and
- * `pr-report` and the Pull Requests Manager page report them.
+ * The labels this repository's queue is made of. They exist only on GitHub, so
+ * these strings, and the ones in `.github/workflows/`, are the whole of their
+ * declaration: `unblock-prs` and `open-pr` act on them, and `pr-report` and the
+ * Pull Requests Manager page report them.
  */
 
 /**
- * The label that says "not yet": the check workflows skip while it is on
- * and `skip-ci-label.yml` holds the merge with a `pending` `no-skip-ci-label`
- * status. It is a label, deliberately — a `skip-ci` in the title means
- * nothing to any workflow.
+ * The label that says "not yet": the check workflows skip while it is on and
+ * `skip-ci-label.yml` holds the merge with a `pending` `no-skip-ci-label`
+ * status. It is a label, deliberately — a `skip-ci` in the title means nothing
+ * to any workflow.
  */
 export const SKIP_CI_LABEL = 'skip-ci';
 
 /**
- * The label that says a pull request has been reviewed and is waiting its
- * turn. It is the whole of `unblock-prs`'s scope rule: a pull request without
- * it is passed over in silence, and one with it is rebased, released from
- * `skip-ci` and watched when its turn comes.
+ * The label that says a pull request has been reviewed and is waiting its turn.
+ * It is the whole of `unblock-prs`'s scope rule: a pull request without it is
+ * passed over in silence, and one with it is rebased, released from `skip-ci`
+ * and watched when its turn comes.
  */
 export const MERGE_QUEUED_LABEL = 'merge-queued';
 
@@ -25,17 +25,16 @@ export const MERGE_QUEUED_LABEL = 'merge-queued';
  * The label a pull request carries to say the next release must contain it:
  * while it is open, the version pull request is not picked.
  *
- * It exists because the version pull request is the one pull request whose
- * body cannot declare a `Merge-After:` — `changesets/action` overwrites the
- * title and body of it on every push to the base — so the ordering is
- * declared from the other side, by the pull request the release is waiting
- * for. A label rather than a trailer for the same reason `merge-queued` is
- * one: this repository is public, and a label needs write access while a
- * comment does not.
+ * It exists because the version pull request is the one pull request whose body
+ * cannot declare a `Merge-After:` — `changesets/action` overwrites the title
+ * and body of it on every push to the base — so the ordering is declared from
+ * the other side, by the pull request the release is waiting for. A label
+ * rather than a trailer for the same reason `merge-queued` is one: this
+ * repository is public, and a label needs write access while a comment does
+ * not.
  *
- * Nothing ever takes it off. The constraint is "open", so it ends when the
- * pull request merges or is closed, and there is no state left behind to
- * clean up.
+ * Nothing ever takes it off. The constraint is "open", so it ends when the pull
+ * request merges or is closed, and there is no state left behind to clean up.
  */
 export const BLOCKS_RELEASE_LABEL = 'blocks-release';
 
@@ -43,22 +42,22 @@ export const BLOCKS_RELEASE_LABEL = 'blocks-release';
  * The label that asks `unblock-prs` to keep a pull request on the tip of the
  * default branch while it waits, so that its diff stays readable for review.
  * It is honoured only together with `skip-ci`, under which the push runs no
- * checks, and only when the queue has nothing to do. `open-pr` puts it on
- * every layer of a stack: one above the bottom is carried along by the layer
- * below, and needs the label of its own once that layer merges and it is
- * moved onto the default branch.
+ * checks, and only when the queue has nothing to do. `open-pr` puts it on every
+ * layer of a stack: one above the bottom is carried along by the layer below,
+ * and needs the label of its own once that layer merges and it is moved onto
+ * the default branch.
  */
 export const AUTO_REBASE_LABEL = 'auto-rebase';
 
 /**
  * The labels that move a pull request within `unblock-prs`'s pick order:
- * among the ones it may pick, those labelled `priority:high` go first and
- * those labelled `priority:low` last, the version pull request included.
- * They decide nothing else — what `Merge-After:`, a stack or
- * `blocks-release` holds back stays held, and a pull request already in
- * flight is watched whatever it carries. One carrying both counts as
- * neither. {@link PRIORITY_MID_LABEL} is not read there: it is the same as
- * carrying neither.
+ * among the ones it may pick, those labelled `priority:high` go first and those
+ * labelled `priority:low` last, the version pull request included.
+ * They decide nothing else — what `Merge-After:`, a stack or `blocks-release`
+ * holds back stays held, and a pull request already in flight is watched
+ * whatever it carries. One carrying both counts as neither.
+ * {@link PRIORITY_MID_LABEL} is not read there: it is the same as carrying
+ * neither.
  */
 export const PRIORITY_HIGH_LABEL = 'priority:high';
 
@@ -72,8 +71,8 @@ export const PRIORITY_MID_LABEL = 'priority:mid';
 
 /**
  * The label that says the author is holding a pull request back for now.
- * Also on GitHub, and read only by the Pull Requests Manager page, whose
- * merge order counts it and can hide what carries it. It asks nothing of
+ * Also on GitHub, and read only by the Pull Requests Manager page, whose merge
+ * order counts it and can hide what carries it. It asks nothing of
  * `unblock-prs`: what is held is simply not labelled `merge-queued`.
  */
 export const PENDING_LABEL = 'pending';
@@ -82,8 +81,8 @@ export const PENDING_LABEL = 'pending';
  * The label that says someone has started an issue, before there is a pull
  * request to say so. `start-issue` puts it on, and refuses an issue that
  * already carries it, so that two sessions do not pick up the same one; the
- * Pull Requests Manager page and `pr-report` show a startable issue carrying
- * it as in progress, as they show one an open pull request closes
+ * Pull Requests Manager page and `pr-report` show a startable issue carrying it
+ * as in progress, as they show one an open pull request closes
  * (`start-after.mts`'s `progressOf`). Nothing takes it off when the work
  * merges: the issue closes, and the label with it stops mattering.
  */
@@ -92,8 +91,7 @@ export const IN_PROGRESS_LABEL = 'in-progress';
 /**
  * The label that says someone means to start an issue next. It holds nothing
  * back — `start-issue` takes it off as it puts {@link IN_PROGRESS_LABEL} on —
- * and only tells whoever is choosing what to start that this one is spoken
- * for; the page and `pr-report` show a startable issue carrying it as
- * planned.
+ * and only tells whoever is choosing what to start that this one is spoken for;
+ * the page and `pr-report` show a startable issue carrying it as planned.
  */
 export const PLANNED_LABEL = 'planned';

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[],