@erclx/canon 5.78.0 → 5.80.0

package/src/git/files.ts

@@ -56,15 +56,18 @@ export async function listChangedFiles(
   root: string,
   base: string,
 ): Promise<string[] | undefined> {
-  const changed = await git(root, ['diff', '--name-only', base])
+  // NUL-separated, since newline output C-quotes a path holding a quote or a
+  // non-ASCII character and the quoted spelling names no file.
+  const changed = await git(root, ['diff', '--name-only', '-z', base])
   const untracked = await git(root, [
     'ls-files',
+    '-z',
     '--others',
     '--exclude-standard',
   ])
   if (changed === undefined || untracked === undefined) return undefined
 
-  const paths = [...changed.split('\n'), ...untracked.split('\n')]
+  const paths = [...changed.split('\0'), ...untracked.split('\0')]
   return [...new Set(paths.filter(Boolean))].sort()
 }
 

package/src/indexes/frontmatter.ts

@@ -17,22 +17,43 @@ export interface Frontmatter {
  * missing block instead of ending the caller's whole run.
  */
 export function parseFrontmatter(source: string): Frontmatter | undefined {
+  const reading = readFrontmatterSource(source)
+  return reading.kind === 'parsed' ? reading.frontmatter : undefined
+}
+
+export type FrontmatterReading =
+  | { readonly kind: 'absent' }
+  | { readonly kind: 'invalid'; readonly message: string }
+  | { readonly kind: 'parsed'; readonly frontmatter: Frontmatter }
+
+/**
+ * Tells a source with no block from one whose block failed to parse, which
+ * `parseFrontmatter` folds into one undefined. A block that parses to a list
+ * or a scalar reads as invalid, since no field can be read off it.
+ */
+export function readFrontmatterSource(source: string): FrontmatterReading {
   const match = source.match(FRONTMATTER)
-  if (!match) return undefined
+  if (!match) return { kind: 'absent' }
 
   let parsed: unknown
   try {
     parsed = Bun.YAML.parse(match[1])
-  } catch {
-    return undefined
+  } catch (error) {
+    return {
+      kind: 'invalid',
+      message: error instanceof Error ? error.message : String(error),
+    }
   }
   if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-    return undefined
+    return { kind: 'invalid', message: 'frontmatter is not a mapping' }
   }
 
   return {
-    raw: match[0],
-    fields: parsed as Record<string, unknown>,
+    kind: 'parsed',
+    frontmatter: {
+      raw: match[0],
+      fields: parsed as Record<string, unknown>,
+    },
   }
 }
 

package/src/indexes/render.ts

@@ -1,5 +1,9 @@
 import { basename, dirname, resolve } from 'node:path'
-import { readField, readFrontmatter } from '@/indexes/frontmatter'
+import {
+  readField,
+  readFrontmatter,
+  readFrontmatterSource,
+} from '@/indexes/frontmatter'
 import { INDEX_FILE, listIndexes } from '@/indexes/walk'
 
 export interface IndexEntry {
@@ -81,8 +85,19 @@ export async function collectEntries(
   const entries: IndexEntry[] = []
   const errors: string[] = []
 
+  let invalid = 0
+
   for (const path of paths) {
-    const frontmatter = await readFrontmatter(path)
+    const reading = readFrontmatterSource(await Bun.file(path).text())
+    if (reading.kind === 'invalid') {
+      invalid += 1
+      errors.push(
+        `frontmatter is not valid YAML in ${path}: ${reading.message}`,
+      )
+      continue
+    }
+    const frontmatter =
+      reading.kind === 'parsed' ? reading.frontmatter : undefined
     const title = readField(frontmatter, 'title')
     const description = readField(frontmatter, 'description')
 
@@ -101,7 +116,10 @@ export async function collectEntries(
   }
 
   if (errors.length > 0) {
-    errors.push(`${errors.length} missing frontmatter field(s) in ${dir}`)
+    const missing = errors.length - invalid
+    if (missing > 0) {
+      errors.push(`${missing} missing frontmatter field(s) in ${dir}`)
+    }
     return { ok: false, errors }
   }
 

package/src/markdown/colons.ts

@@ -30,6 +30,12 @@ const BOLD_LABEL = /^(\*\*|__)[^*_]+\1$/
 /** What may stand in a lead once its code spans and links are masked. */
 const CONNECTIVE = /\b(?:and|or|to)\b|,/g
 
+/** Words and apostrophes or hyphens between them, with no sentence punctuation. */
+const PLAIN_LEAD = /^[\p{L}\p{N}][\p{L}\p{N}'’ -]*$/u
+
+/** The longest plain lead a line may open on and still read as a label. */
+const LEAD_WORDS = 3
+
 /** Blanks a span while holding its width, so a column stays where it was. */
 function blank(match: string): string {
   return ' '.repeat(match.length)
@@ -38,16 +44,20 @@ function blank(match: string): string {
 /**
  * Whether the text before a line's first colon is a label rather than a
  * clause: the lead of a list item, or a prefix that is only emphasis and a
- * masked code span. A list item's lead also reads as a label at any length
- * when only code spans, links, commas, and `and`, `or`, or `to` stand in it,
- * which is a file entry naming several paths.
+ * masked code span. A line, after any quote marker, also reads as a label when
+ * its lead is at most three plain words, such as `Issue` or `Test strategy`.
+ * A list item's lead also reads as a label at any length when only code spans,
+ * links, commas, and `and`, `or`, or `to` stand in it, which is a file entry
+ * naming several paths.
  */
 function isLabel(prefix: string, listItem: boolean): boolean {
   if (BOLD_LABEL.test(prefix.trim())) return true
 
   const words = prefix.replace(/[*_]/g, ' ').trim()
   if (words === '') return true
-  if (!listItem) return false
+  if (!listItem) {
+    return PLAIN_LEAD.test(words) && words.split(/\s+/).length <= LEAD_WORDS
+  }
   if (words.replace(CONNECTIVE, ' ').trim() === '') return true
   return words.split(/\s+/).length <= 4
 }

package/src/markdown/heading-case.ts

@@ -14,15 +14,22 @@ const TITLE = /^title:\s*(["']?)(.*?)\1\s*$/
 const CODE_SPAN = /(`+)(?:(?!\1).)*\1/g
 const CAPITALIZED = /^[A-Z][a-z]/
 
+/** A task's phase label, `v` and dotted digits, which the template fixes. */
+const PHASE_LABEL = /^v\d+\.\d+:\s+/
+
 /**
  * The words of `text` that break sentence case.
  *
  * A code span stands for one lowercase word, so a heading opening on one
  * counts that span as its first word. The first word with a letter in it is
- * exempt, which keeps a leading numeral from promoting the next word.
+ * exempt, which keeps a leading numeral from promoting the next word. A
+ * leading phase label is not a word of the heading, so the first word is the
+ * one after it.
  */
 function capitalizedAfterFirst(text: string): string[] {
-  const masked = maskDisplayed(text.replace(CODE_SPAN, 'code'))
+  const masked = maskDisplayed(
+    text.replace(PHASE_LABEL, '').replace(CODE_SPAN, 'code'),
+  )
     .replace(/\s+/g, ' ')
     .trim()
   const words = masked === '' ? [] : masked.split(' ')

package/src/pr/bijection.ts

@@ -1,4 +1,5 @@
 import type { RenamePair } from '@/git/files'
+import { findMislinked, type Mislinked } from '@/pr/links'
 import { extractKeyChangePaths, KEY_CHANGES, type PathClaim } from '@/pr/paths'
 
 /**
@@ -62,6 +63,12 @@ export interface BijectionReport {
    * comparison has no way to tell a stale claim from one it could not check.
    */
   readonly evidenceUnread: boolean
+  /**
+   * Links in the section whose anchor hashes a path other than the one their
+   * label names, which open the wrong file's diff. Empty for a body that links
+   * nothing, since an unlinked path is the ordinary form.
+   */
+  readonly mislinked: readonly Mislinked[]
 }
 
 export type Bijection =
@@ -231,6 +238,7 @@ export function compareKeyChanges(input: BijectionInput): Bijection {
     unnamed: reached.filter((path) => !owesNoBullet(path)),
     incidental: reached.filter(owesNoBullet),
     evidenceUnread,
+    mislinked: findMislinked(input.body, input.changed),
   }
 }
 

package/src/pr/evidence.ts

@@ -46,6 +46,9 @@ const FOLDED_SUMMARY = 'Within tolerance'
 /** The heading every body opens with. */
 const EVIDENCE_HEADING = '## Evidence'
 
+/** How the line counting renamed images whose pixels did not change opens. */
+const MOVED_PREFIX = '**Moved unchanged:**'
+
 /** How the visible commit line opens. */
 const BASE_PREFIX = '**Base:**'
 
@@ -82,14 +85,18 @@ const IMAGE_EXTENSION = /\.(png|jpe?g|gif|webp|avif|svg)$/i
 export interface EvidenceItem {
   readonly path: string
   readonly stem: string
-  /** True when `path` did not exist at the comparison's base commit. */
+  /** True when `path` did not exist at the comparison's base commit and was not renamed from a path that did. */
   readonly added: boolean
+  /** Where a renamed image sat at the base, which its before image reads from. Absent for any image that was not renamed. */
+  readonly basePath?: string
   /** Pixel width of the head image, read from its PNG header. Absent when unread. */
   readonly width?: number
   /** Pixel width of the base image, absent for an added case or an unread header. */
   readonly baseWidth?: number
   /** Whether the head differs from its base by no more than sub-visual noise. Absent when the pair was not compared. */
   readonly withinTolerance?: boolean
+  /** Whether the head and base files hold the same bytes. Read only for a renamed image, where it alone lets the listing drop the pair, since a small edit also passes the tolerance. */
+  readonly identical?: boolean
 }
 
 export interface EvidenceState {
@@ -131,11 +138,13 @@ function splitEvidencePath(path: string): {
 /**
  * Groups every evidence path in `changed` by its state, keying each entry
  * inside a state by filename stem so a before/after pair sharing a name
- * across two states can be read as one case.
+ * across two states can be read as one case. A path in `renamedFrom` was moved
+ * from the path it maps to, so it is not added and its base reads from there.
  */
 export async function groupEvidence(
   changed: readonly string[],
   existsAtBase: ExistsAtBase,
+  renamedFrom: ReadonlyMap<string, string> = new Map(),
 ): Promise<EvidenceReading> {
   const paths = changed.filter(isEvidencePath)
   if (paths.length === 0) return { kind: 'refused', reason: 'no-evidence' }
@@ -143,14 +152,20 @@ export async function groupEvidence(
   const resolved = await Promise.all(
     paths.map(async (path) => {
       const { state, stem } = splitEvidencePath(path)
-      const added = !(await existsAtBase(path))
-      return { path, state, stem, added }
+      const basePath = renamedFrom.get(path)
+      const added = basePath === undefined && !(await existsAtBase(path))
+      return { path, state, stem, added, basePath }
     }),
   )
 
   const byState = new Map<string, EvidenceItem[]>()
-  for (const { path, state, stem, added } of resolved) {
-    const item: EvidenceItem = { path, stem, added }
+  for (const { path, state, stem, added, basePath } of resolved) {
+    const item: EvidenceItem = {
+      path,
+      stem,
+      added,
+      ...(basePath !== undefined && { basePath }),
+    }
     const items = byState.get(state)
     if (items === undefined) byState.set(state, [item])
     else items.push(item)
@@ -283,7 +298,7 @@ function baseFold(item: EvidenceItem, repo: string, base: string): string[] {
     '<summary>Base</summary>',
     '',
     evidenceImage(
-      rawUrl(repo, base, item.path),
+      rawUrl(repo, base, item.basePath ?? item.path),
       `${escapeCell(item.stem)} base`,
       item.baseWidth,
     ),
@@ -576,8 +591,16 @@ export function renderEvidenceBody(
     states
       .map((entry) => ({ ...entry, items: entry.items.filter(keep) }))
       .filter((entry) => entry.items.length > 0)
-  const open = split((item) => item.withinTolerance !== true)
-  const folded = split((item) => item.withinTolerance === true)
+  const isMoved = (item: EvidenceItem): boolean =>
+    item.basePath !== undefined && item.identical === true
+  const open = split((item) => !isMoved(item) && item.withinTolerance !== true)
+  const folded = split(
+    (item) => !isMoved(item) && item.withinTolerance === true,
+  )
+  const movedCount = states.reduce(
+    (total, entry) => total + entry.items.filter(isMoved).length,
+    0,
+  )
 
   const headCount = open.reduce((total, entry) => total + entry.items.length, 0)
   const opener =
@@ -592,6 +615,12 @@ export function renderEvidenceBody(
     ...opening,
     `${BASE_PREFIX} ${commitLink(repo, base)} · **Head:** ${commitLink(repo, head)}`,
     '',
+    ...(movedCount === 0
+      ? []
+      : [
+          `${MOVED_PREFIX} ${movedCount} ${movedCount === 1 ? 'image' : 'images'}`,
+          '',
+        ]),
     ...sections,
     '',
     ...closing,

package/src/pr/health.ts

@@ -1,18 +1,26 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
+/** The key listing folders whose listeners skip the health paths. */
+export const PAGE_ONLY_KEY = 'page-only'
+
 /** Where a project declares what `canon pr local` checks beyond the page. */
 export const LOCAL_CONFIG_REL = join('canon', 'config', 'local.toml')
 
 /**
- * The health paths a project declared. `none` is an absent file or an empty
- * `health = []`. `invalid` is a declaration that exists and cannot be used,
- * which refuses rather than falling back to the page-only probe, since that
- * fallback is the failure the declaration exists to catch.
+ * The health paths a project declared, with the folders whose listeners skip
+ * them. `none` is an absent file or an empty `health = []`. `invalid` is a
+ * declaration that exists and cannot be used, which refuses rather than
+ * falling back to the page-only probe, since that fallback is the failure the
+ * declaration exists to catch.
  */
 export type HealthDeclaration =
-  | { readonly kind: 'paths'; readonly paths: readonly string[] }
-  | { readonly kind: 'none' }
+  | {
+      readonly kind: 'paths'
+      readonly paths: readonly string[]
+      readonly pageOnly: readonly string[]
+    }
+  | { readonly kind: 'none'; readonly pageOnly: readonly string[] }
   | { readonly kind: 'invalid'; readonly reason: string }
 
 /**
@@ -28,9 +36,24 @@ function isLocalPath(entry: unknown): entry is string {
   )
 }
 
+/**
+ * A repository-relative folder as whole segments, or undefined when the entry
+ * is not one. Absolute paths, drive letters, backslashes, and `..` refuse,
+ * since each would name a place outside the repository. A leading `./` and
+ * trailing slashes are dropped so the match compares segments alone.
+ */
+function toFolder(entry: unknown): string | undefined {
+  if (typeof entry !== 'string') return undefined
+  if (entry.startsWith('/') || entry.includes('\\')) return undefined
+  if (/^[A-Za-z]:/.test(entry)) return undefined
+  const segments = entry.split('/').filter((s) => s !== '' && s !== '.')
+  if (segments.length === 0 || segments.includes('..')) return undefined
+  return segments.join('/')
+}
+
 export function readHealthPaths(root: string): HealthDeclaration {
   const path = join(root, LOCAL_CONFIG_REL)
-  if (!existsSync(path)) return { kind: 'none' }
+  if (!existsSync(path)) return { kind: 'none', pageOnly: [] }
 
   let parsed: Record<string, unknown>
   try {
@@ -42,15 +65,40 @@ export function readHealthPaths(root: string): HealthDeclaration {
     return { kind: 'invalid', reason: `${LOCAL_CONFIG_REL} is not valid TOML` }
   }
 
-  const declared = parsed.health
-  if (!Array.isArray(declared) || !declared.every(isLocalPath)) {
-    return {
-      kind: 'invalid',
-      reason: `${LOCAL_CONFIG_REL} needs health as a list of paths, each starting with a single /`,
+  const hasHealth = 'health' in parsed
+  const hasPageOnly = PAGE_ONLY_KEY in parsed
+  if (!hasHealth && !hasPageOnly) return invalidHealth()
+
+  let paths: readonly string[] = []
+  if (hasHealth) {
+    const declared = parsed.health
+    if (!Array.isArray(declared) || !declared.every(isLocalPath)) {
+      return invalidHealth()
     }
+    paths = declared
   }
 
-  return declared.length === 0
-    ? { kind: 'none' }
-    : { kind: 'paths', paths: declared }
+  let pageOnly: readonly string[] = []
+  if (hasPageOnly) {
+    const declared = parsed[PAGE_ONLY_KEY]
+    const folders = Array.isArray(declared) ? declared.map(toFolder) : []
+    if (!Array.isArray(declared) || folders.includes(undefined)) {
+      return {
+        kind: 'invalid',
+        reason: `${LOCAL_CONFIG_REL} needs ${PAGE_ONLY_KEY} as a list of folders relative to the repository, with no leading / and no ..`,
+      }
+    }
+    pageOnly = folders as string[]
+  }
+
+  return paths.length === 0
+    ? { kind: 'none', pageOnly }
+    : { kind: 'paths', paths, pageOnly }
+}
+
+function invalidHealth(): HealthDeclaration {
+  return {
+    kind: 'invalid',
+    reason: `${LOCAL_CONFIG_REL} needs health as a list of paths, each starting with a single /`,
+  }
 }

package/src/pr/links.ts

@@ -0,0 +1,160 @@
+import { createHash } from 'node:crypto'
+import { findBacktickSpans } from '@/markdown/backticks'
+import { KEY_CHANGES, LINE_SUFFIX, readSectionAt } from '@/pr/paths'
+
+/** A Key changes link whose anchor hashes a path other than its label's. */
+export interface Mislinked {
+  readonly path: string
+  readonly anchor: string
+}
+
+/**
+ * The fragment GitHub gives a file's diff in a pull request's Files tab, being
+ * `diff-` and the SHA-256 of the raw path. Read off a merged pull request's
+ * rendered page, so a path holding a space or a bracket hashes as written.
+ */
+export function diffAnchor(path: string): string {
+  return `diff-${createHash('sha256').update(path).digest('hex')}`
+}
+
+interface Located {
+  readonly text: string
+  readonly offset: number
+  readonly whole: string
+}
+
+/** The section's text and where it starts, in the body with line endings normalized. */
+function locateSection(body: string, title: string): Located | undefined {
+  const whole = body.replace(/\r\n/g, '\n')
+  const found = readSectionAt(whole, title)
+  return found === undefined ? undefined : { ...found, whole }
+}
+
+/** Blanks every code span, keeping offsets, so a bracket inside a path never reads as link syntax. */
+function maskSpans(text: string): string {
+  let out = text
+  for (const span of findBacktickSpans(text)) {
+    out =
+      out.slice(0, span.start) +
+      ' '.repeat(span.end - span.start) +
+      out.slice(span.end)
+  }
+  return out
+}
+
+/**
+ * An inline link: a destination bare or in angle brackets, then an optional
+ * quoted title. A form this misses reads as no link, and a span inside it then
+ * gets a second link nested in the first.
+ */
+const LINK =
+  /\[[^\]]*\]\(\s*(<[^>]*>|[^)\s]*)(?:\s+(?:"[^"]*"|'[^']*'))?\s*\)/dg
+const DIFF_DESTINATION = /#diff-[0-9a-f]{64}$/
+
+interface Edit {
+  readonly start: number
+  readonly end: number
+  readonly text: string
+}
+
+/**
+ * Writes each code span in `## Key changes` that names a changed file as a link
+ * to that file's diff, keeping the span as the label.
+ *
+ * Only an exact changed path is linked. A partial spelling or a folder names no
+ * single row in the Files tab, and a link to a guessed row is worse than none.
+ *
+ * A span that is the whole label of an existing diff link has its destination
+ * rewritten, which is how a wrong anchor clears. A span anywhere else inside a
+ * link's brackets is left alone, since a link nested in a link breaks the
+ * bullet, and the rewrite stays idempotent.
+ *
+ * `filesUrl` is the pull request's `/files` address, absolute because the body
+ * becomes the squash commit message, where a relative link resolves nowhere.
+ */
+export function linkKeyChanges(
+  body: string,
+  changed: readonly string[],
+  filesUrl: string,
+): string {
+  const located = locateSection(body, KEY_CHANGES)
+  if (located === undefined) return body
+
+  const { text } = located
+  const known = new Set(changed)
+  const links = [...maskSpans(text).matchAll(LINK)].map((match) => ({
+    start: match.index ?? 0,
+    end: (match.index ?? 0) + match[0].length,
+    destination: match[1] ?? '',
+    destinationStart: match.indices?.[1]?.[0] ?? 0,
+  }))
+
+  const edits: Edit[] = []
+  for (const span of findBacktickSpans(text)) {
+    const path = span.content.replace(LINE_SUFFIX, '')
+    if (!known.has(path)) continue
+    const target = `${filesUrl}#${diffAnchor(path)}`
+
+    const link = links.find((l) => l.start < span.start && span.end <= l.end)
+    if (link === undefined) {
+      edits.push({
+        start: span.start,
+        end: span.end,
+        text: `[${text.slice(span.start, span.end)}](${target})`,
+      })
+      continue
+    }
+
+    const wholeLabel =
+      span.start === link.start + 1 && text.startsWith('](', span.end)
+    if (!wholeLabel || !DIFF_DESTINATION.test(link.destination)) continue
+    edits.push({
+      start: link.destinationStart,
+      end: link.destinationStart + link.destination.length,
+      text: target,
+    })
+  }
+
+  let out = ''
+  let cursor = 0
+  for (const edit of edits) {
+    out += text.slice(cursor, edit.start) + edit.text
+    cursor = edit.end
+  }
+  out += text.slice(cursor)
+
+  return (
+    located.whole.slice(0, located.offset) +
+    out +
+    located.whole.slice(located.offset + text.length)
+  )
+}
+
+const DIFF_LINK = /\[(`+)([^`]+)\1\]\([^)\s]*#(diff-[0-9a-f]{64})\)/g
+
+/**
+ * Every Key changes link whose label is a changed path and whose anchor hashes
+ * another path.
+ *
+ * A label that is no changed path, such as a bare file name or a function, is
+ * left unjudged: it can open the right file under a spelling this cannot map
+ * back to a row, and an accusation needs the row.
+ */
+export function findMislinked(
+  body: string,
+  changed: readonly string[],
+): Mislinked[] {
+  const located = locateSection(body, KEY_CHANGES)
+  if (located === undefined) return []
+
+  const known = new Set(changed)
+  const out: Mislinked[] = []
+  for (const match of located.text.matchAll(DIFF_LINK)) {
+    const path = (match[2] ?? '').trim().replace(LINE_SUFFIX, '')
+    const anchor = match[3] ?? ''
+    if (known.has(path) && diffAnchor(path) !== anchor) {
+      out.push({ path, anchor })
+    }
+  }
+  return out
+}

package/src/pr/local.ts

@@ -45,6 +45,11 @@ async function firstFailingPath(
   return undefined
 }
 
+/** Whether `cwd` is `folder` or inside it, compared on whole path segments. */
+function isUnder(cwd: string, folder: string): boolean {
+  return cwd === folder || cwd.startsWith(`${folder}/`)
+}
+
 /**
  * Finds the server this worktree is running: the lowest port whose listening
  * process runs inside the worktree, answers an HTTP probe, and passes every
@@ -53,11 +58,14 @@ async function firstFailingPath(
  * lower one is the page by convention. Health is read on the page's own port,
  * since that is the address a reviewer drives, and a page whose backend fails
  * refuses as `unhealthy` naming the lowest page port's first failing path.
+ * A port whose listener runs under a `pageOnly` folder, matched on whole
+ * segments, is found on the page probe alone.
  */
 export async function findLocalServer(
   worktreeRoot: string,
   runner: LocalRunner,
   healthPaths: readonly string[] = [],
+  pageOnly: readonly string[] = [],
 ): Promise<LocalResult> {
   const listeners = await runner.listListeners()
   if (listeners === undefined) {
@@ -65,17 +73,22 @@ export async function findLocalServer(
   }
 
   const cwdByPid = new Map<number, string | undefined>()
-  const ports = new Set<number>()
+  const ports = new Map<number, boolean>()
+  const folders = pageOnly.map((folder) => `${worktreeRoot}/${folder}`)
   for (const { pid, port } of listeners) {
     if (!cwdByPid.has(pid)) cwdByPid.set(pid, await runner.cwdOf(pid))
     const cwd = cwdByPid.get(pid)
-    if (cwd !== undefined && belongsTo(cwd, worktreeRoot)) ports.add(port)
+    if (cwd === undefined || !belongsTo(cwd, worktreeRoot)) continue
+    const skipsHealth = folders.some((folder) => isUnder(cwd, folder))
+    ports.set(port, (ports.get(port) ?? false) || skipsHealth)
   }
 
   let unhealthy: (HealthFailure & { readonly port: number }) | undefined
-  for (const port of [...ports].sort((a, b) => a - b)) {
+  for (const [port, skipsHealth] of [...ports].sort(([a], [b]) => a - b)) {
     if (!(await runner.probe(port))) continue
-    const failure = await firstFailingPath(port, healthPaths, runner)
+    const failure = skipsHealth
+      ? undefined
+      : await firstFailingPath(port, healthPaths, runner)
     if (failure === undefined) {
       return { kind: 'found', port, url: `http://localhost:${port}` }
     }