@erclx/canon 5.73.0 → 5.74.0

package/src/pr/merge.ts

@@ -1,4 +1,4 @@
-import type { ChecksGate } from '@/pr/lift'
+import { advisoryOf, type ChecksGate } from '@/pr/lift'
 import { readSection } from '@/pr/paths'
 import { UI_PASS_MARKER } from '@/pr/tick'
 
@@ -67,6 +67,8 @@ export interface MergeRecord {
   readonly description?: string
   /** The squash commit, present only on a merge. */
   readonly sha?: string
+  /** Failing checks the base does not require, which the merge went past. */
+  readonly advisory?: readonly string[]
 }
 
 export type Composed =
@@ -230,8 +232,15 @@ export async function merge(
     )
   }
 
-  if (opts.isDryRun)
-    return { reason: 'dry-run', isOk: true, number, ...message }
+  if (opts.isDryRun) {
+    return {
+      reason: 'dry-run',
+      isOk: true,
+      number,
+      ...message,
+      ...advisoryOf(checks),
+    }
+  }
 
   const outcome = await api.putMerge({ ...message, sha: pull.head })
   if (outcome.kind === 'merged') {
@@ -241,6 +250,7 @@ export async function merge(
       number,
       ...message,
       sha: outcome.sha,
+      ...advisoryOf(checks),
     }
   }
   return refused(

package/src/targets/pulls.ts

@@ -94,6 +94,8 @@ interface RawPull {
  * rather than writing a second collapse beside `rollup`.
  */
 export interface RawCheck {
+  /** The check-run name, which a ruleset's required context matches. */
+  readonly name?: string
   readonly status?: string
   readonly conclusion?: string
   readonly state?: string
@@ -137,6 +139,46 @@ export function rollup(checks: readonly RawCheck[]): ChecksState | null {
   return running ? 'pending' : 'passing'
 }
 
+/** A head's state over the checks the base requires, with failing others named apart. */
+export interface RequiredRollup {
+  readonly state: ChecksState | null
+  /** Names of checks outside the required set that failed, which never gate. */
+  readonly advisory: readonly string[]
+}
+
+/**
+ * Collapses a head's checks over the set the base branch's rules require.
+ *
+ * An unread or empty set gates by every check, which is `rollup` itself and
+ * the safe default for a repository whose rules list nothing. A required name
+ * with no run on the head reads pending rather than passing, since a run not
+ * yet created has not cleared anything.
+ */
+export function rollupRequired(
+  checks: readonly RawCheck[],
+  required: ReadonlySet<string> | undefined,
+): RequiredRollup {
+  if (required === undefined || required.size === 0) {
+    return { state: rollup(checks), advisory: [] }
+  }
+
+  const isRequired = (check: RawCheck): boolean =>
+    check.name !== undefined && required.has(check.name)
+  const gating = checks.filter(isRequired)
+  const advisory = checks
+    .filter((check) => !isRequired(check) && rollup([check]) === 'failing')
+    .map((check) => check.name ?? '')
+
+  const state = rollup(gating)
+  const isMissing = [...required].some(
+    (name) => !gating.some((check) => check.name === name),
+  )
+  return {
+    state: state !== 'failing' && isMissing ? 'pending' : state,
+    advisory,
+  }
+}
+
 /**
  * Reads the heading of the newest pass carrying one, matching on the first line
  * alone the way `poll.ts` does.