heyquilt 0.3.122 → 0.3.140

package/src/quilts/xdiff.js

@@ -1,435 +0,0 @@
-// A port of git's xdiff line diff (Myers with xdiff's heuristics, record cleanup, and change
-// compaction with the indent heuristic), so `blame` and `diff` choose the same lines git does.
-//
-// Ported from git's xdiff/xprepare.c, xdiff/xdiffi.c and xdiff-interface.c (trim_common_tail).
-// LibXDiff by Davide Libenzi, Copyright (C) 2003, LGPL-2.1-or-later; git's changes are under the
-// same terms. Structure and names follow the C so the two can be compared line by line.
-
-const XDL_KPDIS_RUN = 4
-const XDL_MAX_EQLIMIT = 1024
-const XDL_SIMSCAN_WINDOW = 100
-const XDL_MAX_COST_MIN = 256
-const XDL_HEUR_MIN_COST = 256
-const XDL_LINE_MAX = Number.MAX_SAFE_INTEGER
-const XDL_SNAKE_CNT = 20
-const XDL_K_HEUR = 4
-const DISCARD = 0; const KEEP = 1; const INVESTIGATE = 2
-
-function bogosqrt (n) { let i = 1; for (; n > 0; n = Math.floor(n / 4)) i *= 2; return i }
-
-/** git's trim_common_tail: the byte length to drop from both ends' tails (blame only). */
-function commonTail (a, b) {
-  const blk = 1024
-  let trimmed = 0; let recovered = 0
-  const smaller = Math.min(a.length, b.length)
-  while (blk + trimmed <= smaller &&
-    a.compare(b, b.length - trimmed - blk, b.length - trimmed, a.length - trimmed - blk, a.length - trimmed) === 0) trimmed += blk
-  const ap = a.length - trimmed
-  while (recovered < trimmed) if (a[ap + recovered++] === 10) break
-  return trimmed - recovered
-}
-
-/** Records of a buffer: [start, end) per line, each with its \n. */
-function records (buf, size) {
-  const starts = []
-  let s = 0
-  while (s < size) {
-    let e = buf.indexOf(10, s)
-    e = e < 0 || e >= size ? size : e + 1
-    starts.push(s, e)
-    s = e
-  }
-  return starts
-}
-
-function prepare (buf, size, classes, counts, pass) {
-  const r = records(buf, size)
-  const n = r.length / 2
-  const mph = new Int32Array(n)
-  for (let i = 0; i < n; i++) {
-    const key = buf.toString('latin1', r[2 * i], r[2 * i + 1])
-    let id = classes.get(key)
-    if (id === undefined) { id = classes.size; classes.set(key, id); counts.push(0, 0) }
-    counts[2 * id + pass]++
-    mph[i] = id
-  }
-  return { buf, r, nrec: n, mph, changed: new Uint8Array(n + 2), ref: null, nreff: 0, dstart: 0, dend: n - 1 }
-}
-
-function cleanMmatch (action, i, len) {
-  let s = 0; let e = len - 1
-  if (i - s > XDL_SIMSCAN_WINDOW) s = i - XDL_SIMSCAN_WINDOW
-  if (e - i > XDL_SIMSCAN_WINDOW) e = i + XDL_SIMSCAN_WINDOW
-  let r; let rdis0 = 0; let rpdis0 = 1; let rdis1 = 0; let rpdis1 = 1
-  for (r = 1; i - r >= s; r++) {
-    const a = action[i - r]
-    if (a === DISCARD) rdis0++
-    else if (a === INVESTIGATE) rpdis0++
-    else break
-  }
-  if (rdis0 === 0) return false
-  for (r = 1; i + r <= e; r++) {
-    const a = action[i + r]
-    if (a === DISCARD) rdis1++
-    else if (a === INVESTIGATE) rpdis1++
-    else break
-  }
-  if (rdis1 === 0) return false
-  rdis1 += rdis0
-  rpdis1 += rpdis0
-  return rpdis1 * XDL_KPDIS_RUN < rpdis1 + rdis1
-}
-
-function trimEnds (x1, x2) {
-  const lim = Math.min(x1.nrec, x2.nrec)
-  let i = 0
-  while (i < lim && x1.mph[i] === x2.mph[i]) i++
-  x1.dstart = x2.dstart = i
-  const lim2 = lim - i
-  let j = 0
-  while (j < lim2 && x1.mph[x1.nrec - 1 - j] === x2.mph[x2.nrec - 1 - j]) j++
-  x1.dend = x1.nrec - j - 1
-  x2.dend = x2.nrec - j - 1
-}
-
-function cleanupRecords (counts, x1, x2) {
-  const off = x1.dstart
-  const len1 = x1.dend - off + 1
-  const len2 = x2.dend - off + 1
-  const one = (x, len, other) => {
-    const action = new Uint8Array(Math.max(len, 0))
-    let mlim = bogosqrt(x.nrec)
-    if (mlim > XDL_MAX_EQLIMIT) mlim = XDL_MAX_EQLIMIT
-    for (let i = 0; i < len; i++) {
-      const nm = counts[2 * x.mph[i + off] + other]
-      action[i] = nm === 0 ? DISCARD : nm < mlim ? KEEP : INVESTIGATE
-    }
-    x.ref = new Int32Array(Math.max(len, 0))
-    x.nreff = 0
-    for (let i = 0; i < len; i++) {
-      let a = action[i]
-      if (a === INVESTIGATE) a = cleanMmatch(action, i, len) ? DISCARD : KEEP
-      if (a === KEEP) x.ref[x.nreff++] = i + off
-      else x.changed[i + off + 1] = 1
-    }
-  }
-  one(x1, len1, 1)
-  one(x2, len2, 0)
-}
-
-function doDiff (x1, x2) {
-  const h1 = new Int32Array(x1.nreff); for (let i = 0; i < x1.nreff; i++) h1[i] = x1.mph[x1.ref[i]]
-  const h2 = new Int32Array(x2.nreff); for (let i = 0; i < x2.nreff; i++) h2[i] = x2.mph[x2.ref[i]]
-  const ndiags = x1.nreff + x2.nreff + 3
-  const kvd = new Float64Array(2 * ndiags + 2)
-  const F = x2.nreff + 1
-  const B = ndiags + x2.nreff + 1
-  let mxcost = bogosqrt(ndiags)
-  if (mxcost < XDL_MAX_COST_MIN) mxcost = XDL_MAX_COST_MIN
-  const snakeCnt = XDL_SNAKE_CNT; const heurMin = XDL_HEUR_MIN_COST
-  const spl = { i1: 0, i2: 0, minLo: 0, minHi: 0 }
-
-  function split (off1, lim1, off2, lim2, needMin) {
-    const dmin = off1 - lim2; const dmax = lim1 - off2
-    const fmid = off1 - off2; const bmid = lim1 - lim2
-    const odd = (fmid - bmid) & 1
-    let fmin = fmid; let fmax = fmid; let bmin = bmid; let bmax = bmid
-    let i1, i2, prev1, best, dd, v, k, d
-    kvd[F + fmid] = off1
-    kvd[B + bmid] = lim1
-    for (let ec = 1; ; ec++) {
-      let gotSnake = false
-      if (fmin > dmin) kvd[F + (--fmin) - 1] = -1; else ++fmin
-      if (fmax < dmax) kvd[F + (++fmax) + 1] = -1; else --fmax
-      for (d = fmax; d >= fmin; d -= 2) {
-        if (kvd[F + d - 1] >= kvd[F + d + 1]) i1 = kvd[F + d - 1] + 1
-        else i1 = kvd[F + d + 1]
-        prev1 = i1
-        i2 = i1 - d
-        while (i1 < lim1 && i2 < lim2 && h1[i1] === h2[i2]) { i1++; i2++ }
-        if (i1 - prev1 > snakeCnt) gotSnake = true
-        kvd[F + d] = i1
-        if (odd && bmin <= d && d <= bmax && kvd[B + d] <= i1) {
-          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
-          return
-        }
-      }
-      if (bmin > dmin) kvd[B + (--bmin) - 1] = XDL_LINE_MAX; else ++bmin
-      if (bmax < dmax) kvd[B + (++bmax) + 1] = XDL_LINE_MAX; else --bmax
-      for (d = bmax; d >= bmin; d -= 2) {
-        if (kvd[B + d - 1] < kvd[B + d + 1]) i1 = kvd[B + d - 1]
-        else i1 = kvd[B + d + 1] - 1
-        prev1 = i1
-        i2 = i1 - d
-        while (i1 > off1 && i2 > off2 && h1[i1 - 1] === h2[i2 - 1]) { i1--; i2-- }
-        if (prev1 - i1 > snakeCnt) gotSnake = true
-        kvd[B + d] = i1
-        if (!odd && fmin <= d && d <= fmax && i1 <= kvd[F + d]) {
-          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
-          return
-        }
-      }
-      if (needMin) continue
-      if (gotSnake && ec > heurMin) {
-        for (best = 0, d = fmax; d >= fmin; d -= 2) {
-          dd = d > fmid ? d - fmid : fmid - d
-          i1 = kvd[F + d]
-          i2 = i1 - d
-          v = (i1 - off1) + (i2 - off2) - dd
-          if (v > XDL_K_HEUR * ec && v > best && off1 + snakeCnt <= i1 && i1 < lim1 && off2 + snakeCnt <= i2 && i2 < lim2) {
-            for (k = 1; h1[i1 - k] === h2[i2 - k]; k++) {
-              if (k === snakeCnt) { best = v; spl.i1 = i1; spl.i2 = i2; break }
-            }
-          }
-        }
-        if (best > 0) { spl.minLo = 1; spl.minHi = 0; return }
-        for (best = 0, d = bmax; d >= bmin; d -= 2) {
-          dd = d > bmid ? d - bmid : bmid - d
-          i1 = kvd[B + d]
-          i2 = i1 - d
-          v = (lim1 - i1) + (lim2 - i2) - dd
-          if (v > XDL_K_HEUR * ec && v > best && off1 < i1 && i1 <= lim1 - snakeCnt && off2 < i2 && i2 <= lim2 - snakeCnt) {
-            for (k = 0; h1[i1 + k] === h2[i2 + k]; k++) {
-              if (k === snakeCnt - 1) { best = v; spl.i1 = i1; spl.i2 = i2; break }
-            }
-          }
-        }
-        if (best > 0) { spl.minLo = 0; spl.minHi = 1; return }
-      }
-      if (ec >= mxcost) {
-        let fbest = -1; let fbest1 = -1
-        for (d = fmax; d >= fmin; d -= 2) {
-          i1 = Math.min(kvd[F + d], lim1)
-          i2 = i1 - d
-          if (lim2 < i2) { i1 = lim2 + d; i2 = lim2 }
-          if (fbest < i1 + i2) { fbest = i1 + i2; fbest1 = i1 }
-        }
-        let bbest = XDL_LINE_MAX; let bbest1 = XDL_LINE_MAX
-        for (d = bmax; d >= bmin; d -= 2) {
-          i1 = Math.max(off1, kvd[B + d])
-          i2 = i1 - d
-          if (i2 < off2) { i1 = off2 + d; i2 = off2 }
-          if (i1 + i2 < bbest) { bbest = i1 + i2; bbest1 = i1 }
-        }
-        if ((lim1 + lim2) - bbest < fbest - (off1 + off2)) {
-          spl.i1 = fbest1; spl.i2 = fbest - fbest1; spl.minLo = 1; spl.minHi = 0
-        } else {
-          spl.i1 = bbest1; spl.i2 = bbest - bbest1; spl.minLo = 0; spl.minHi = 1
-        }
-        return
-      }
-    }
-  }
-
-  // xdl_recs_cmp, with its recursion on an explicit stack (depth can reach thousands).
-  const stack = [[0, x1.nreff, 0, x2.nreff, 0]]
-  while (stack.length) {
-    let [off1, lim1, off2, lim2, needMin] = stack.pop()
-    while (off1 < lim1 && off2 < lim2 && h1[off1] === h2[off2]) { off1++; off2++ }
-    while (off1 < lim1 && off2 < lim2 && h1[lim1 - 1] === h2[lim2 - 1]) { lim1--; lim2-- }
-    if (off1 === lim1) {
-      for (; off2 < lim2; off2++) x2.changed[x2.ref[off2] + 1] = 1
-    } else if (off2 === lim2) {
-      for (; off1 < lim1; off1++) x1.changed[x1.ref[off1] + 1] = 1
-    } else {
-      spl.i1 = spl.i2 = 0
-      split(off1, lim1, off2, lim2, needMin)
-      const { i1, i2, minLo, minHi } = spl
-      // Low half first, as the C recursion does (it only marks, so order matters not for the
-      // result, but keep it for fidelity).
-      stack.push([i1, lim1, i2, lim2, minHi])
-      stack.push([off1, i1, off2, i2, minLo])
-    }
-  }
-}
-
-// --- change compaction (xdl_change_compact) with the indent heuristic ---
-
-const MAX_INDENT = 200
-const MAX_BLANKS = 20
-const START_OF_FILE_PENALTY = 1
-const END_OF_FILE_PENALTY = 21
-const TOTAL_BLANK_WEIGHT = -30
-const POST_BLANK_WEIGHT = 6
-const RELATIVE_INDENT_PENALTY = -4
-const RELATIVE_INDENT_WITH_BLANK_PENALTY = 10
-const RELATIVE_OUTDENT_PENALTY = 24
-const RELATIVE_OUTDENT_WITH_BLANK_PENALTY = 17
-const RELATIVE_DEDENT_PENALTY = 23
-const RELATIVE_DEDENT_WITH_BLANK_PENALTY = 17
-const INDENT_WEIGHT = 60
-const INDENT_HEURISTIC_MAX_SLIDING = 100
-
-function getIndent (x, i) {
-  let ret = 0
-  const buf = x.buf
-  for (let p = x.r[2 * i], e = x.r[2 * i + 1]; p < e; p++) {
-    const c = buf[p]
-    // isspace: space, \t, \n, \v, \f, \r
-    if (!(c === 32 || (c >= 9 && c <= 13))) return ret
-    else if (c === 32) ret += 1
-    else if (c === 9) ret += 8 - ret % 8
-    if (ret >= MAX_INDENT) return MAX_INDENT
-  }
-  return -1
-}
-
-function measureSplit (x, split) {
-  const m = { eof: 0, indent: -1, preBlank: 0, preIndent: -1, postBlank: 0, postIndent: -1 }
-  if (split >= x.nrec) { m.eof = 1; m.indent = -1 } else m.indent = getIndent(x, split)
-  for (let i = split - 1; i >= 0; i--) {
-    m.preIndent = getIndent(x, i)
-    if (m.preIndent !== -1) break
-    m.preBlank += 1
-    if (m.preBlank === MAX_BLANKS) { m.preIndent = 0; break }
-  }
-  for (let i = split + 1; i < x.nrec; i++) {
-    m.postIndent = getIndent(x, i)
-    if (m.postIndent !== -1) break
-    m.postBlank += 1
-    if (m.postBlank === MAX_BLANKS) { m.postIndent = 0; break }
-  }
-  return m
-}
-
-function scoreAddSplit (m, s) {
-  if (m.preIndent === -1 && m.preBlank === 0) s.penalty += START_OF_FILE_PENALTY
-  if (m.eof) s.penalty += END_OF_FILE_PENALTY
-  const postBlank = m.indent === -1 ? 1 + m.postBlank : 0
-  const totalBlank = m.preBlank + postBlank
-  s.penalty += TOTAL_BLANK_WEIGHT * totalBlank
-  s.penalty += POST_BLANK_WEIGHT * postBlank
-  const indent = m.indent !== -1 ? m.indent : m.postIndent
-  const anyBlanks = totalBlank !== 0
-  s.effectiveIndent += indent
-  if (indent === -1 || m.preIndent === -1) {
-    // no adjustment
-  } else if (indent > m.preIndent) {
-    s.penalty += anyBlanks ? RELATIVE_INDENT_WITH_BLANK_PENALTY : RELATIVE_INDENT_PENALTY
-  } else if (indent === m.preIndent) {
-    // same level
-  } else if (m.postIndent !== -1 && m.postIndent > indent) {
-    s.penalty += anyBlanks ? RELATIVE_OUTDENT_WITH_BLANK_PENALTY : RELATIVE_OUTDENT_PENALTY
-  } else {
-    s.penalty += anyBlanks ? RELATIVE_DEDENT_WITH_BLANK_PENALTY : RELATIVE_DEDENT_PENALTY
-  }
-}
-
-function scoreCmp (s1, s2) {
-  const c = (s1.effectiveIndent > s2.effectiveIndent) - (s1.effectiveIndent < s2.effectiveIndent)
-  return INDENT_WEIGHT * c + (s1.penalty - s2.penalty)
-}
-
-// `changed` is offset by one: changed[i + 1] is record i; changed[0] and changed[nrec + 1] are 0.
-function changeCompact (x, xo) {
-  const ch = x.changed; const cho = xo.changed
-  const C = (i) => ch[i + 1]
-  const CO = (i) => cho[i + 1]
-  const g = { start: 0, end: 0 }; const go = { start: 0, end: 0 }
-  while (C(g.end)) g.end++
-  while (CO(go.end)) go.end++
-  const next = (xx, c, gg) => {
-    if (gg.end === xx.nrec) return -1
-    gg.start = gg.end + 1
-    for (gg.end = gg.start; c(gg.end); gg.end++);
-    return 0
-  }
-  const previous = (c, gg) => {
-    if (gg.start === 0) return -1
-    gg.end = gg.start - 1
-    for (gg.start = gg.end; c(gg.start - 1); gg.start--);
-    return 0
-  }
-  const slideDown = () => {
-    if (g.end < x.nrec && x.mph[g.start] === x.mph[g.end]) {
-      ch[g.start++ + 1] = 0
-      ch[g.end++ + 1] = 1
-      while (C(g.end)) g.end++
-      return 0
-    }
-    return -1
-  }
-  const slideUp = () => {
-    if (g.start > 0 && x.mph[g.start - 1] === x.mph[g.end - 1]) {
-      ch[--g.start + 1] = 1
-      ch[--g.end + 1] = 0
-      while (C(g.start - 1)) g.start--
-      return 0
-    }
-    return -1
-  }
-  const bug = (s) => { throw new Error('xdiff: ' + s) }
-  for (;;) {
-    if (g.end !== g.start) {
-      let groupsize, earliestEnd, endMatchingOther
-      do {
-        groupsize = g.end - g.start
-        endMatchingOther = -1
-        while (!slideUp()) if (previous(CO, go)) bug('group sync broken sliding up')
-        earliestEnd = g.end
-        if (go.end > go.start) endMatchingOther = g.end
-        for (;;) {
-          if (slideDown()) break
-          if (next(xo, CO, go)) bug('group sync broken sliding down')
-          if (go.end > go.start) endMatchingOther = g.end
-        }
-      } while (groupsize !== g.end - g.start)
-      if (g.end === earliestEnd) {
-        // no shifting possible
-      } else if (endMatchingOther !== -1) {
-        while (go.end === go.start) {
-          if (slideUp()) bug('match disappeared')
-          if (previous(CO, go)) bug('group sync broken sliding to match')
-        }
-      } else {
-        let shift = earliestEnd
-        let bestShift = -1; let bestScore = null
-        if (g.end - groupsize - 1 > shift) shift = g.end - groupsize - 1
-        if (g.end - INDENT_HEURISTIC_MAX_SLIDING > shift) shift = g.end - INDENT_HEURISTIC_MAX_SLIDING
-        for (; shift <= g.end; shift++) {
-          const score = { effectiveIndent: 0, penalty: 0 }
-          scoreAddSplit(measureSplit(x, shift), score)
-          scoreAddSplit(measureSplit(x, shift - groupsize), score)
-          if (bestShift === -1 || scoreCmp(score, bestScore) <= 0) { bestScore = score; bestShift = shift }
-        }
-        while (g.end > bestShift) {
-          if (slideUp()) bug('best shift unreached')
-          if (previous(CO, go)) bug('group sync broken sliding to blank line')
-        }
-      }
-    }
-    if (next(x, C, g)) break
-    if (next(xo, CO, go)) bug('group sync broken moving to next group')
-  }
-}
-
-/**
- * git's diff of two byte buffers: hunks [{ a: [start, len], b: [start, len] }] over their lines
- * (a final line without \n counts as different from the same line with one). `trimTail`
- * reproduces what git does for a zero-context diff (blame): drop the common tail in 1 KiB blocks.
- */
-export function xdiff (a, b, { trimTail = false } = {}) {
-  let sa = a.length; let sb = b.length
-  if (trimTail) { const t = commonTail(a, b); sa -= t; sb -= t }
-  const classes = new Map(); const counts = []
-  const x1 = prepare(a, sa, classes, counts, 0)
-  const x2 = prepare(b, sb, classes, counts, 1)
-  trimEnds(x1, x2)
-  cleanupRecords(counts, x1, x2)
-  doDiff(x1, x2)
-  changeCompact(x1, x2)
-  changeCompact(x2, x1)
-  // xdl_build_script, forwards.
-  const out = []
-  const c1 = x1.changed; const c2 = x2.changed
-  let i1 = 0; let i2 = 0
-  while (i1 < x1.nrec || i2 < x2.nrec) {
-    if (c1[i1 + 1] || c2[i2 + 1]) {
-      const s1 = i1; const s2 = i2
-      while (c1[i1 + 1]) i1++
-      while (c2[i2 + 1]) i2++
-      out.push({ a: [s1, i1 - s1], b: [s2, i2 - s2] })
-    } else { i1++; i2++ }
-  }
-  return out
-}

package/src/relay-ci.js

@@ -1,111 +0,0 @@
-// CI on GitHub becomes work on the board: checks failing on a branch the session follows open one task,
-// "CI failing on <branch>", for the member whose commit it is (when they are in the session); a newer commit
-// failing too is noted on it; checks passing again move it to Done. One task per branch (its id comes from the
-// branch), so a run reported twice never adds a second.
-import crypto from 'node:crypto'
-import { readTasks, addTask, updateTask } from './tasks.js'
-import { addComment } from './task-comments.js'
-import { githubWriter } from './github-commit.js'
-import { credentialsFor } from './relay-commit.js'
-import { upstreamsOf, parseRepo } from './relay-upstream.js'
-import { memberForAuthor, everyone } from './relay-clash.js'
-import { runGit } from './relay-git.js'
-import { RELAY_BY } from './branches.js'
-
-const ORIGIN = 'relay-publish'
-// What GitHub calls a check suite that failed (check_suite.conclusion).
-const FAILED = new Set(['failure', 'timed_out', 'action_required', 'startup_failure'])
-
-/** The task id for CI on `branch` of this session: the same every time. */
-export const ciTaskId = (room, branch) => crypto.createHash('sha256').update(`ci\0${room.name}\0${branch}`).digest('hex').slice(0, 16)
-
-/** Who made commit `sha` (from the relay's mirror): the member it maps to, or ''. */
-async function authorOf (room, rec, sha) {
-  if (!room.mirrors) return ''
-  try {
-    const repo = parseRepo(`https://${rec.repo}`)
-    const dir = (await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })).dir
-    const r = await runGit(dir, ['log', '-1', '--format=%an%x1f%ae', sha])
-    if (!r.ok) return ''
-    const [name, email] = r.out.trim().split('\x1f')
-    // By their noreply address, else by name: a member on record, or one connected now.
-    const online = room.names ? [...room.names.values()] : []
-    return memberForAuthor(room, { name, email }) || everyone(room).find((m) => m.name === name)?.name || online.find((n) => n === name) || ''
-  } catch { return '' }
-}
-
-/**
- * A check suite on `repo` finished at commit `sha` of `branch` with `conclusion`. When the session follows that
- * branch: failing opens (or reopens, or notes) its CI task; passing moves an open one to Done. Returns what it did
- * ('opened', 'noted', 'closed') or null. Never throws.
- */
-export function noteCiResult (room, result, opts = {}) {
-  // One at a time per branch, in the order GitHub's results arrive: a failure takes longer to note (GitHub is asked
-  // which checks failed), and a pass right after it must not be noted first.
-  if (!room.ciQueue) room.ciQueue = new Map()
-  const k = String(result && result.branch)
-  const next = (room.ciQueue.get(k) || Promise.resolve()).then(() => noteCiResultNow(room, result, opts))
-  room.ciQueue.set(k, next.catch(() => null))
-  return next
-}
-
-/** Whether commit `older` is an ancestor of `newer` in the relay's mirror of `rec`'s repository (false when it can't say). */
-async function before (room, rec, older, newer) {
-  try {
-    const repo = parseRepo(`https://${rec.repo}`)
-    const dir = (await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })).dir
-    return (await runGit(dir, ['merge-base', '--is-ancestor', older, newer])).ok
-  } catch { return false }
-}
-
-async function noteCiResultNow (room, { repo, sha, branch, conclusion }, { fetch = globalThis.fetch, log = () => {} } = {}) {
-  try {
-    const want = String(repo).toLowerCase().replace(/^github\.com\//, '')
-    const rec = Object.values(upstreamsOf(room)).find((r) => r && r.repo && r.ref === branch && String(r.repo).toLowerCase().replace(/^github\.com\//, '') === want)
-    if (!rec || !/^[0-9a-f]{40}$/.test(sha || '')) return null
-    const failed = FAILED.has(String(conclusion))
-    if (!failed && conclusion !== 'success') return null
-    // A failure on an older commit than one that passed since (GitHub's results can come out of order) is old news.
-    if (!room.ciPassed) room.ciPassed = new Map()
-    const passed = room.ciPassed.get(branch)
-    if (!failed) room.ciPassed.set(branch, sha)
-    else if (passed && passed !== sha && room.mirrors && await before(room, rec, sha, passed)) return null
-    const map = room.doc.getMap('tasks')
-    const id = ciTaskId(room, branch)
-    const task = readTasks(map).find((t) => t.id === id)
-    const open = task && !task.archived && task.column !== 'done'
-    const comment = (text) => addComment(room.doc, room.doc.getMap('taskComments'), readTasks(map), { taskId: id, by: RELAY_BY, text }, ORIGIN)
-    if (!failed) {
-      if (!open) return null
-      comment(`CI passes again on ${branch} at ${sha.slice(0, 7)}.`)
-      updateTask(room.doc, map, { id, column: 'done' }, ORIGIN)
-      return 'closed'
-    }
-    // Which checks failed, when GitHub says (a failing suite is enough to act on).
-    let names = []
-    try {
-      const r = parseRepo(`https://${rec.repo}`)
-      const c = await githubWriter({ fetch, token: await credentialsFor(room, r), owner: r.owner, name: r.name }).checks(sha)
-      names = c.failing || []
-    } catch (err) { log(`[${room.name}] ${branch}: could not read which checks failed on ${sha.slice(0, 7)}: ${err.message}`) }
-    const what = names.length ? names.slice(0, 5).join(', ') : 'checks'
-    // The relay shut down while GitHub was asked: the room notes it when it is back (server.js runCi).
-    if (room.destroyed) return null
-    const url = `https://${rec.repo}/commit/${sha}`
-    if (open) {
-      comment(`Still failing at ${sha.slice(0, 7)}: ${what}. ${url}`)
-      return 'noted'
-    }
-    const who = await authorOf(room, rec, sha)
-    if (room.destroyed) return null
-    const title = `CI failing on ${branch}: ${what}`
-    if (task) updateTask(room.doc, map, { id, title, column: 'todo', archived: false, ...(who ? { assignee: who } : {}) }, ORIGIN)
-    else addTask(room.doc, map, { id, title, by: RELAY_BY, assignee: who, column: 'todo' }, ORIGIN)
-    comment(`GitHub's checks failed on ${branch} at ${sha.slice(0, 7)}: ${what}. ${url}${who ? ` The commit is ${who}'s.` : ''}`)
-    log(`[${room.name}] ${branch}: CI failing at ${sha.slice(0, 7)} (${what}): task ${id}${who ? ` for ${who}` : ''}`)
-    return 'opened'
-  } catch (err) {
-    log(`[${room.name}] ${branch}: could not note CI on ${String(sha).slice(0, 7)}: ${err.message}`)
-    return null
-  }
-}