pr-report-core 0.1.0 → 0.2.1

package/src/queue-owner.mts

@@ -4,26 +4,26 @@
  * Who is to move each pull request in the queue next: the worker
  * (`pnpm run unblock-prs`), a skill, a person, or — which is a bug — nobody.
  *
- * The worker and the `/unblock-prs` skill move the same queue side by side
- * and cannot see each other. Each used to decide for itself whether a
+ * The worker and the `/unblock-prs` skill move the same queue side by side and
+ * cannot see each other. Each used to decide for itself whether a
  * set-aside still stood, from its own reading of the tip of the default
- * branch, and when the two readings differed each left the pull request to
- * the other (#2267). So the answer is decided here, once, and every reader
- * asks this function: the worker before it acts, `pr-report` for the skill,
+ * branch, and when the two readings differed each left the pull request to the
+ * other (#2267). So the answer is decided here, once, and every reader asks
+ * this function: the worker before it acts, `pr-report` for the skill,
  * `claim-pr` before it lets a claim be written, and `report-unowned-prs` to
  * turn `none` into an issue.
  *
  * **It reads the comments and the pull request, never the tip of the base.**
- * The set-aside comment is the hand-off: it stands until the worker rewrites
- * it as resolved — when the head moves, when a retry is asked for, or, for a
+ * The set-aside comment is the hand-off: it stands until the worker rewrites it
+ * as resolved — when the head moves, when a retry is asked for, or, for a
  * reason tied to the base, when the base moves and the worker takes the pull
- * request back to try again. Until then it is the skill's or a person's, and
- * a worker that has stopped running leaves it so rather than nobody's.
+ * request back to try again. Until then it is the skill's or a person's, and a
+ * worker that has stopped running leaves it so rather than nobody's.
  *
  * **Every reason the worker sets aside for has an owner**
  * ({@link setAsideOwner}, exhaustive over {@link SET_ASIDE_REASONS}), so `none`
- * is only ever a combination nothing here expected: a reason this module
- * does not know, written by a worker newer than the reader.
+ * is only ever a combination nothing here expected: a reason this module does
+ * not know, written by a worker newer than the reader.
  */
 
 import { claimApplies, type ClaimComment } from './claim.mjs';
@@ -40,8 +40,8 @@ export const QUEUE_OWNERS = ['worker', 'skill', 'human', 'none'] as const;
 
 /**
  * `skill` is the `/unblock-prs` skill, which fixes every queued pull request
- * the worker sets aside — a branch the repository generates included, which
- * it builds again rather than rebases (`generatedBranches` in
+ * the worker sets aside — a branch the repository generates included, which it
+ * builds again rather than rebases (`generatedBranches` in
  * `.github/unblock-prs.json`).
  */
 export type QueueOwner = Readonly<{
@@ -64,87 +64,6 @@ export const SET_ASIDE_REASONS = [
 
 export type SetAsideReason = (typeof SET_ASIDE_REASONS)[number];
 
-/**
- * Whose a pull request set aside for `reason` is, while the comment stands
- * at its head. A skill's reason is one a session can fix by pushing: a
- * conflict to resolve, a failure to reproduce. A person's is one only a
- * setting, a permission, a review or a merge by hand clears, and the comment
- * says which. A `switch` with no default, so a reason added to
- * {@link SET_ASIDE_REASONS} without an owner fails to compile.
- */
-const setAsideOwner = (
-  reason: SetAsideReason,
-): Readonly<{ owner: 'human' | 'skill'; why: string }> => {
-  switch (reason) {
-    case 'checks-failed':
-    case 'rebase-failed':
-      return { owner: 'skill', why: 'the skill fixes it' };
-
-    case 'already-in-base':
-      return {
-        owner: 'human',
-        why: 'every commit is already in the base; close it',
-      };
-
-    case 'arm-failed':
-      return {
-        owner: 'human',
-        why: 'auto-merge could not be armed; a setting or a permission holds it',
-      };
-
-    case 'awaiting-bypass':
-      return {
-        owner: 'human',
-        why: 'green, and only a ruleset bypass merges it',
-      };
-
-    case 'not-merging':
-      return {
-        owner: 'human',
-        why: 'green but not merging; something the worker cannot read holds it',
-      };
-
-    case 'push-failed':
-      return {
-        owner: 'human',
-        why: 'the push was refused; a setting or a permission holds it',
-      };
-
-    case 'unlabel-failed':
-      return {
-        owner: 'human',
-        why: '`skip-ci` could not be taken off; a permission holds it',
-      };
-
-    case 'watch-timeout':
-      return {
-        owner: 'human',
-        why: 'its checks ran past the watch; look at the run',
-      };
-  }
-};
-
-/** What {@link queueOwner} reads about one pull request. */
-export type QueueOwnerInput = Readonly<{
-  number: number;
-  labels: readonly string[];
-  isDraft: boolean;
-  fromFork: boolean;
-  headRef: string;
-  headSha: string;
-  baseRef: string;
-  defaultBranch: string;
-  /** The open pull request whose branch this one is on, if any. */
-  stackedOn: number | undefined;
-  /** Whether it sits on a `Merge-After` cycle. */
-  inCycle: boolean;
-  /** This account's set-aside comment on it (`set-aside.mts`). */
-  setAside: SetAsideComment | undefined;
-  /** This account's claim comment on it (`claim.mts`). */
-  claim: ClaimComment | undefined;
-  nowEpochMs: number;
-}>;
-
 /**
  * Who moves `pr` next, or `undefined` for a pull request the queue does not
  * cover: neither `merge-queued` nor `auto-rebase` under `skip-ci`.
@@ -177,8 +96,8 @@ export const queueOwner = (pr: QueueOwnerInput): QueueOwner | undefined => {
     return { owner: 'human', reason: unmovable };
   }
 
-  // A layer waits for the one below whatever it says, and the worker carries
-  // it along when that one moves.
+  // A layer waits for the one below whatever it says, and the worker carries it
+  // along when that one moves.
   if (pr.stackedOn !== undefined) {
     return {
       owner: 'worker',
@@ -250,9 +169,93 @@ export const queueOwnerOfEntry = (
     nowEpochMs: context.nowEpochMs,
   });
 
+export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
+  KNOWN_REASONS.has(reason);
+
 /**
- * The set-aside `comment` says, if it stands at `headSha` with no retry
- * asked for. The base is not read: see the module comment.
+ * Whose a pull request set aside for `reason` is, while the comment stands at
+ * its head. A skill's reason is one a session can fix by pushing: a conflict to
+ * resolve, a failure to reproduce. A person's is one only a setting, a
+ * permission, a review or a merge by hand clears, and the comment says which. A
+ * `switch` with no default, so a reason added to {@link SET_ASIDE_REASONS}
+ * without an owner fails to compile.
+ */
+const setAsideOwner = (
+  reason: SetAsideReason,
+): Readonly<{ owner: 'human' | 'skill'; why: string }> => {
+  switch (reason) {
+    case 'checks-failed':
+    case 'rebase-failed':
+      return { owner: 'skill', why: 'the skill fixes it' };
+
+    case 'already-in-base':
+      return {
+        owner: 'human',
+        why: 'every commit is already in the base; close it',
+      };
+
+    case 'arm-failed':
+      return {
+        owner: 'human',
+        why: 'auto-merge could not be armed; a setting or a permission holds it',
+      };
+
+    case 'awaiting-bypass':
+      return {
+        owner: 'human',
+        why: 'green, and only a ruleset bypass merges it',
+      };
+
+    case 'not-merging':
+      return {
+        owner: 'human',
+        why: 'green but not merging; something the worker cannot read holds it',
+      };
+
+    case 'push-failed':
+      return {
+        owner: 'human',
+        why: 'the push was refused; a setting or a permission holds it',
+      };
+
+    case 'unlabel-failed':
+      return {
+        owner: 'human',
+        why: '`skip-ci` could not be taken off; a permission holds it',
+      };
+
+    case 'watch-timeout':
+      return {
+        owner: 'human',
+        why: 'its checks ran past the watch; look at the run',
+      };
+  }
+};
+
+/** What {@link queueOwner} reads about one pull request. */
+export type QueueOwnerInput = Readonly<{
+  number: number;
+  labels: readonly string[];
+  isDraft: boolean;
+  fromFork: boolean;
+  headRef: string;
+  headSha: string;
+  baseRef: string;
+  defaultBranch: string;
+  /** The open pull request whose branch this one is on, if any. */
+  stackedOn: number | undefined;
+  /** Whether it sits on a `Merge-After` cycle. */
+  inCycle: boolean;
+  /** This account's set-aside comment on it (`set-aside.mts`). */
+  setAside: SetAsideComment | undefined;
+  /** This account's claim comment on it (`claim.mts`). */
+  claim: ClaimComment | undefined;
+  nowEpochMs: number;
+}>;
+
+/**
+ * The set-aside `comment` says, if it stands at `headSha` with no retry asked
+ * for. The base is not read: see the module comment.
  */
 const standingAt = (
   comment: SetAsideComment | undefined,
@@ -264,14 +267,11 @@ const standingAt = (
     ? comment.setAside
     : undefined;
 
-export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
-  KNOWN_REASONS.has(reason);
-
 const KNOWN_REASONS: ReadonlySet<string> = new Set(SET_ASIDE_REASONS);
 
 /**
- * Why nothing in the queue can move `pr` until a person does something, if
- * so: the worker passes these over with a note, and no skill takes them up.
+ * Why nothing in the queue can move `pr` until a person does something, if so:
+ * the worker passes these over with a note, and no skill takes them up.
  */
 const unmovableReason = (pr: QueueOwnerInput): string | undefined =>
   pr.isDraft

package/src/queue-owner.test.mts

@@ -188,8 +188,8 @@ describe(queueOwner, () => {
       },
     );
 
-    // The same as for any other branch: which branches are generated, and
-    // how, is the repository's configuration, which the skill reads.
+    // The same as for any other branch: which branches are generated, and how,
+    // is the repository's configuration, which the skill reads.
     assert.deepStrictEqual(
       queueOwner({ ...update, setAside: standing('rebase-failed') }),
       {

package/src/report.mts

@@ -29,8 +29,8 @@ import type {
 /**
  * Reads the declared merge order and the check verdicts out of the facts.
  *
- * Nothing here talks to GitHub, which is what lets the whole shape of a
- * report be tested against a handful of literals.
+ * Nothing here talks to GitHub, which is what lets the whole shape of a report
+ * be tested against a handful of literals.
  */
 export const buildReport = ({
   repo,
@@ -82,49 +82,6 @@ export const buildReport = ({
     issuesLimit,
   }) as const;
 
-/**
- * Each open issue with how it stands for being started
- * (`docs/issue-start-after.md`): its start state, or how far someone has
- * got with it when it is startable (`progressOf`), and where each thing it
- * names stands.
- */
-const reportIssues = (
-  issues: readonly OpenIssue[],
-  pulls: readonly PullRequestFacts[],
-  references: ReadonlyMap<number, ReferenceStatus>,
-): readonly ReportIssue[] => {
-  const listed = new Set(issues.map(({ number }) => number));
-
-  const open = new Set(pulls.map(({ number }) => number));
-
-  const statusOf = (number: number): ReferenceStatus =>
-    listed.has(number) || open.has(number)
-      ? 'waiting'
-      : (references.get(number) ?? 'unknown');
-
-  const states = decideStartStates(issues, statusOf);
-
-  const worked = issuesInProgress(pulls);
-
-  return issues.map((issue) => ({
-    ...issue,
-    start: withProgress(
-      states.get(issue.number) ?? 'free',
-      progressOf(issue.labels, worked.has(issue.number)),
-    ),
-    named: issue.startAfter.map((number) => ({
-      number,
-      status: statusOf(number),
-    })),
-  }));
-};
-
-export type DecidedEntries = Readonly<{
-  entries: readonly ReportEntry[];
-  roots: readonly TreeNode[];
-  cycles: readonly (readonly number[])[];
-}>;
-
 /**
  * The part of a report that is decided rather than read: each open pull
  * request's declared order, the stack it is in, its check verdict, and the
@@ -139,8 +96,8 @@ export const buildEntries = ({
 }: Readonly<{
   /**
    * The contexts the ruleset requires, or `undefined` for a repository that
-   * declares none: each pull request is then judged over every context
-   * reported on its head.
+   * declares none: each pull request is then judged over every context reported
+   * on its head.
    */
   required: readonly string[] | undefined;
   defaultBranch: string;
@@ -236,6 +193,49 @@ export const buildEntries = ({
   return { entries, roots, cycles };
 };
 
+/**
+ * Each open issue with how it stands for being started
+ * (`docs/issue-start-after.md`): its start state, or how far someone has got
+ * with it when it is startable (`progressOf`), and where each thing it names
+ * stands.
+ */
+const reportIssues = (
+  issues: readonly OpenIssue[],
+  pulls: readonly PullRequestFacts[],
+  references: ReadonlyMap<number, ReferenceStatus>,
+): readonly ReportIssue[] => {
+  const listed = new Set(issues.map(({ number }) => number));
+
+  const open = new Set(pulls.map(({ number }) => number));
+
+  const statusOf = (number: number): ReferenceStatus =>
+    listed.has(number) || open.has(number)
+      ? 'waiting'
+      : (references.get(number) ?? 'unknown');
+
+  const states = decideStartStates(issues, statusOf);
+
+  const worked = issuesInProgress(pulls);
+
+  return issues.map((issue) => ({
+    ...issue,
+    start: withProgress(
+      states.get(issue.number) ?? 'free',
+      progressOf(issue.labels, worked.has(issue.number)),
+    ),
+    named: issue.startAfter.map((number) => ({
+      number,
+      status: statusOf(number),
+    })),
+  }));
+};
+
+export type DecidedEntries = Readonly<{
+  entries: readonly ReportEntry[];
+  roots: readonly TreeNode[];
+  cycles: readonly (readonly number[])[];
+}>;
+
 const NO_DECLARATIONS: IssueDeclarations = {
   startAfter: new Map<number, readonly number[]>(),
   open: new Set<number>(),
@@ -243,8 +243,8 @@ const NO_DECLARATIONS: IssueDeclarations = {
 
 /**
  * The issues a pull request closes that may still declare an order: any not
- * known to be closed. One read from the body without a token has an
- * `unknown` state, and is given the benefit of the doubt.
+ * known to be closed. One read from the body without a token has an `unknown`
+ * state, and is given the benefit of the doubt.
  */
 const notKnownClosed = (
   linkedIssues: PullRequestFacts['linkedIssues'],

package/src/review-hold.mts

@@ -5,18 +5,18 @@
  * `main`'s ruleset asks for two things no check reports: an approval from a
  * code owner of every owned path the pull request touches, and every review
  * conversation resolved. A queued pull request missing either goes green and
- * sits there, and a rebase cannot change that. Released anyway, it costs a
- * full matrix and holds the queue for the length of a watch; and because
- * `main` moving is what puts it back in the running, it would be rebased and
- * run again every time anything else merged. So triage reads both before
- * picking, and leaves a pull request they hold in the queue with a note,
- * until an approval or a resolved conversation changes the answer.
+ * sits there, and a rebase cannot change that. Released anyway, it costs a full
+ * matrix and holds the queue for the length of a watch; and because `main`
+ * moving is what puts it back in the running, it would be rebased and run again
+ * every time anything else merged. So triage reads both before picking, and
+ * leaves a pull request they hold in the queue with a note, until an approval
+ * or a resolved conversation changes the answer.
  *
  * Except when nothing can change it: GitHub does not let an author approve
  * their own pull request, so one whose waiting paths only its author owns
- * merges by a ruleset bypass or not at all. Holding that one would hold it
- * for ever, with `skip-ci` on and no verdict for whoever makes the bypass
- * merge to go by. So it is released and watched like any other, with
+ * merges by a ruleset bypass or not at all. Holding that one would hold it for
+ * ever, with `skip-ci` on and no verdict for whoever makes the bypass merge to
+ * go by. So it is released and watched like any other, with
  * auto-merge left off — it could never fire — until its checks report, and
  * then left for that person (`awaiting-bypass`).
  *
@@ -50,11 +50,11 @@ export type ReviewRules = Readonly<{
 }>;
 
 /**
- * What the review does to the pull request: `held` waits for an approval or
- * a resolved conversation, `bypass` waits for nobody — only its author owns
- * what is waiting — and `undefined` holds nothing. What cannot be told for
- * sure — changed files past what could be read — holds nothing: the watch
- * still catches a pull request that goes green and does not merge, and
+ * What the review does to the pull request: `held` waits for an approval or a
+ * resolved conversation, `bypass` waits for nobody — only its author owns what
+ * is waiting — and `undefined` holds nothing. What cannot be told for sure —
+ * changed files past what could be read — holds nothing: the watch still
+ * catches a pull request that goes green and does not merge, and
  * `demotions.mts` is what follows.
  */
 export type ReviewHold = Readonly<{ kind: 'bypass' | 'held'; reason: string }>;

package/src/review-hold.test.mts

@@ -123,9 +123,9 @@ describe(reviewHold, () => {
     );
   });
 
-  // A changed file past what could be read might be owned, but "might" is not
-  // a reason to hold the queue: the watch still catches a pull request that
-  // goes green and does not merge.
+  // A changed file past what could be read might be owned, but "might" is not a
+  // reason to hold the queue: the watch still catches a pull request that goes
+  // green and does not merge.
   test('holds nothing it cannot be sure of', () => {
     assert.isUndefined(
       reviewHold(

package/src/ruleset.mts

@@ -10,8 +10,8 @@ export type RulesetRequirements = Readonly<{
   /** The contexts a pull request has to satisfy. */
   requiredContexts: readonly string[];
   /**
-   * Whether a change to a path `.github/CODEOWNERS` lists waits for one of
-   * its owners to approve it.
+   * Whether a change to a path `.github/CODEOWNERS` lists waits for one of its
+   * owners to approve it.
    */
   requireCodeOwnerReview: boolean;
   /** Whether every review conversation has to be resolved first. */
@@ -23,11 +23,10 @@ export type RulesetRequirements = Readonly<{
  * `pnpm run pr-report`, which reads the checkout. The file is the desired
  * state; what GitHub enforces is {@link requirementsOfRules} over
  * `rules/branches/{branch}`, which `unblock-prs` and the Pull Requests
- * Manager read and which wants no more than read access. The gap is that a
- * file under `repo-settings/` changes nothing until
- * `pnpm run repo-settings:apply` runs, so a context added here and not
- * applied is reported as missing on every pull request — which is a fair
- * thing for a report to say out loud.
+ * Manager read and which wants no more than read access. The gap is that a file
+ * under `repo-settings/` changes nothing until `pnpm run repo-settings:apply`
+ * runs, so a context added here and not applied is reported as missing on every
+ * pull request — which is a fair thing for a report to say out loud.
  *
  * `source` names the file in the messages.
  */
@@ -98,8 +97,8 @@ const RulesetSchema = t.record({ rules: t.array(t.unknown()) });
 
 /**
  * One rule of the several kinds a ruleset holds. The others carry entirely
- * different parameters, so each rule is tried against this and the ones that
- * do not match are simply not the rule being looked for.
+ * different parameters, so each rule is tried against this and the ones that do
+ * not match are simply not the rule being looked for.
  *
  * Written here rather than taken from `octokit-safe-types`, whose
  * `RepositoryRule` is the whole union: validating against it would refuse a
@@ -126,8 +125,8 @@ const ConversationResolutionRuleSchema = t.record({
 
 /**
  * The rules as read: `ruleset.test.mts` checks each against GitHub's API
- * description, so that a field read here that GitHub renames or retypes
- * fails the type check.
+ * description, so that a field read here that GitHub renames or retypes fails
+ * the type check.
  */
 export type RequiredStatusChecksRule = t.TypeOf<
   typeof RequiredStatusChecksRuleSchema

package/src/set-aside.mts

@@ -1,30 +1,30 @@
 /**
  * Why `unblock-prs` set a pull request aside, written where GitHub keeps it.
  *
- * The script decides on someone's machine and says so on standard output,
- * which is where nobody can see it afterwards. So each time it sets a pull
- * request aside it also writes a comment on that pull request — one per pull
- * request, edited in place from then on — whose first line is a hidden
- * record this module writes and reads back, and whose last line is a task
- * box a person ticks to have the script try again. What lies between is
- * prose for whoever reads it, and nothing reads it back. The Pull Requests
+ * The script decides on someone's machine and says so on standard output, which
+ * is where nobody can see it afterwards. So each time it sets a pull request
+ * aside it also writes a comment on that pull request — one per pull request,
+ * edited in place from then on — whose first line is a hidden record this
+ * module writes and reads back, and whose last line is a task box a person
+ * ticks to have the script try again. What lies between is prose for whoever
+ * reads it, and nothing reads it back. The Pull Requests
  * Manager page and the script itself read the record; anyone else reads the
  * prose on the pull request.
  *
  * **A comment rather than a commit status**, which is what it used to be. A
- * status has no state that means "for information": `failure` left a red ✗ on
- * a context nothing requires, until the next push, with 140 characters to say
+ * status has no state that means "for information": `failure` left a red ✗ on a
+ * context nothing requires, until the next push, with 140 characters to say
  * why, and nobody could take it off or ask for another try. **Rather than the
  * body**, because the author, a session and `open-pr` write the body too, the
  * REST API has no conditional update to keep an edit made in between, and the
  * version pull request's body is rewritten on every push to the base.
  *
- * **Only the comments the reader's own account wrote count.** The repository
- * is public, so anyone can post a comment that starts with the marker; the
- * script and the page both ask GitHub for `viewerDidAuthor` and read nothing
- * else — the account that runs `unblock-prs` is the one that looks at the
- * page. A task box in someone else's comment can be ticked only by those who
- * can write to the repository, so the retry is not open to outsiders either.
+ * **Only the comments the reader's own account wrote count.** The repository is
+ * public, so anyone can post a comment that starts with the marker; the script
+ * and the page both ask GitHub for `viewerDidAuthor` and read nothing else —
+ * the account that runs `unblock-prs` is the one that looks at the page. A task
+ * box in someone else's comment can be ticked only by those who can write to
+ * the repository, so the retry is not open to outsiders either.
  *
  * **Its own record rather than GitHub's `mergeable`.** That answers whether
  * *merging* the branch conflicts, from a cached background computation; the
@@ -32,8 +32,8 @@
  * parent was squash-merged and on a cache that has not caught up. Only the
  * script knows what the rebase said.
  *
- * **It lasts exactly as long as the state it was reached in.** The record
- * names the head and the base it was reached at; a push moves the head, and
+ * **It lasts exactly as long as the state it was reached in.** The record names
+ * the head and the base it was reached at; a push moves the head, and
  * {@link setAsideApplies} is where a moved head and a moved base are judged,
  * for the script and the page alike. Once it no longer applies, or a person
  * asked for a retry, the script rewrites the comment to one resolved line
@@ -60,9 +60,9 @@ export type SetAside = Readonly<{
 }>;
 
 /**
- * What one of the script's comments says: a pull request still set aside,
- * and whether a person has ticked the retry box on it, or one that was and
- * is not any more.
+ * What one of the script's comments says: a pull request still set aside, and
+ * whether a person has ticked the retry box on it, or one that was and is not
+ * any more.
  */
 export type SetAsideComment = Readonly<
   | { kind: 'resolved' }
@@ -70,9 +70,9 @@ export type SetAsideComment = Readonly<
 >;
 
 /**
- * The record line, `prose`, and an empty retry box on the last line. The
- * whole SHAs rather than short ones, because what reads them back compares
- * them with the head and the base.
+ * The record line, `prose`, and an empty retry box on the last line. The whole
+ * SHAs rather than short ones, because what reads them back compares them with
+ * the head and the base.
  */
 export const writeSetAsideComment = (
   setAside: SetAside,
@@ -148,11 +148,11 @@ export const setAsideApplies = (
  * judged the head.
  *
  * Every reason clears when the base moves, because a moved base is the one
- * thing the script knows how to act on — a rebase that conflicted may not
- * any more — except two whose head a rebase would only put through the same
- * matrix again: `checks-failed`, which the push that carries the fix clears,
- * and `awaiting-bypass`, green and waiting for a ruleset bypass merge, which
- * does not wait for the base.
+ * thing the script knows how to act on — a rebase that conflicted may not any
+ * more — except two whose head a rebase would only put through the same matrix
+ * again: `checks-failed`, which the push that carries the fix clears, and
+ * `awaiting-bypass`, green and waiting for a ruleset bypass merge, which does
+ * not wait for the base.
  */
 export const setAsideStillApplies = (
   setAside: Readonly<{ reason: string; baseSha: string }>,

package/src/stack.mts

@@ -3,13 +3,13 @@
  * branch, so that its diff is its own layer and nothing below it.
  *
  * The stack is read from the bases alone, because GitHub already holds it: a
- * pull request onto `a` is on top of whichever pull request is `a`'s. When
- * that one merges, GitHub moves the layer above it onto its base and rebases
- * it, so the base chain is the merge order, and everything that orders pull
- * requests here reads a parent as a `Merge-After:` on it. `open-pr --base`
- * writes that trailer too, so that the body states the order as it does for
- * every other; a stack made any other way, without one, counts all the same,
- * and one naming the parent is not counted twice.
+ * pull request onto `a` is on top of whichever pull request is `a`'s. When that
+ * one merges, GitHub moves the layer above it onto its base and rebases it, so
+ * the base chain is the merge order, and everything that orders pull requests
+ * here reads a parent as a `Merge-After:` on it. `open-pr --base` writes that
+ * trailer too, so that the body states the order as it does for every other; a
+ * stack made any other way, without one, counts all the same, and one naming
+ * the parent is not counted twice.
  */
 
 /** The fields a stack is read from. */
@@ -20,8 +20,8 @@ export type StackMember = Readonly<{
   headRef: string;
   baseRef: string;
   /**
-   * Whether the head branch lives in a fork. A fork's branch is not a branch
-   * of this repository, whatever its name, so it is never a parent.
+   * Whether the head branch lives in a fork. A fork's branch is not a branch of
+   * this repository, whatever its name, so it is never a parent.
    */
   fromFork: boolean;
 }>;
@@ -31,9 +31,9 @@ export type StackMember = Readonly<{
  * A pull request that is not stacked has no entry.
  *
  * A base is a parent's head only when exactly one open pull request from this
- * repository heads it: a branch opened against two bases is two pull
- * requests, and which of them a layer above means cannot be told. Nothing
- * onto the default branch is stacked, even if some odd pull request heads it.
+ * repository heads it: a branch opened against two bases is two pull requests,
+ * and which of them a layer above means cannot be told. Nothing onto the
+ * default branch is stacked, even if some odd pull request heads it.
  */
 export const findStackParents = (
   pulls: readonly StackMember[],
@@ -60,9 +60,8 @@ export const findStackParents = (
 };
 
 /**
- * Every layer above `number`, each after the one it is on — the order in
- * which they are moved when `number` moves. Siblings keep the lowest number
- * first.
+ * Every layer above `number`, each after the one it is on — the order in which
+ * they are moved when `number` moves. Siblings keep the lowest number first.
  */
 export const stackDescendants = (
   parents: ReadonlyMap<number, number>,