@erclx/canon 5.77.0 → 5.79.0

package/src/design/templates/preview.html

@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">{{favicon}}
+<title>Design tokens</title>
+<link rel="stylesheet" href="design.css">
+<style>
+{{chrome}}
+  body { font-family: {{bodyStack}}; margin: 2rem; max-width: 960px; color: var(--preview-ink); background: var(--preview-paper); }
+  h1 { margin-top: 0; }
+  h2 { margin-top: 2rem; border-bottom: 1px solid var(--preview-rule); padding-bottom: 0.25rem; }
+  table { border-collapse: collapse; width: 100%; margin-top: 0.5rem; }
+  th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid var(--preview-rule); font-size: 14px; }
+  th { background: var(--preview-panel); font-weight: 600; }
+  .swatch { display: inline-block; width: 1.5rem; height: 1.5rem; border-radius: 4px; border: 1px solid var(--preview-rule); vertical-align: middle; margin-right: 0.5rem; }
+  .bar { display: inline-block; height: 1rem; background: var(--preview-muted); border-radius: 2px; vertical-align: middle; }
+  .note { color: var(--preview-muted); font-size: 13px; margin-top: 0.5rem; }
+  .empty { color: var(--preview-muted); font-style: italic; }{{verifyStyle}}
+</style>
+</head>
+<body>
+<h1>Design tokens</h1>
+<p class="note">Generated from <code>canon/DESIGN.md</code> by <code>bun run web:previews</code>. Token preview only, not a screen mock.</p>{{summary}}
+{{sections}}
+</body>
+</html>
+

package/src/design/templates/scrollbar.css

@@ -0,0 +1,29 @@
+* {
+  scrollbar-width: thin;
+  scrollbar-color: var(--color-border) transparent;
+}
+
+*::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+
+*::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+*::-webkit-scrollbar-thumb {
+  border-radius: var(--radius-marker);
+  background: var(--color-border);
+  /* Inset by painting a border in the page color, which is what keeps the
+     thumb off the edges without a second element. */
+  border: 3px solid var(--color-background);
+}
+
+*::-webkit-scrollbar-thumb:hover {
+  background: var(--color-muted);
+}
+
+*::-webkit-scrollbar-corner {
+  background: transparent;
+}

package/src/design/templates/status.css

@@ -0,0 +1,24 @@
+.status {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.42rem;
+  font-size: 0.75rem;
+  font-weight: 500;
+  letter-spacing: 0;
+  text-transform: none;
+  color: var(--color-muted);
+  white-space: nowrap;
+}
+
+.status::before {
+  content: '';
+  width: 6px;
+  height: 6px;
+  flex: none;
+  border-radius: var(--radius-marker);
+  background: var(--color-border);
+}
+
+.status.is-done::before {
+  background: var(--color-accent);
+}

package/src/gate/embedded.ts

@@ -0,0 +1,400 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { plural } from '@/cli/ui'
+import type { Emission, Measure } from '@/gate/measures'
+import { listRepositoryFiles } from '@/git/files'
+import { isMarked } from '@/sweep/exempt-marker'
+
+export const EMBEDDED_MARKER = 'canon-allow-embedded'
+
+/**
+ * Static lines a page, stylesheet, or script may hold inline. Matches the
+ * limit `governance/rules/tooling/ci-workflow.md` sets on a `run:` step, so a
+ * sixth line is where a block leaves for its own file.
+ */
+export const EMBEDDED_LINE_LIMIT = 5
+
+export type EmbeddedKind = 'page' | 'stylesheet' | 'script'
+
+export interface EmbeddedBlock {
+  readonly file: string
+  readonly line: number
+  readonly kind: EmbeddedKind
+  readonly lines: number
+  /** A script that branches counts at any length, so the finding says which. */
+  readonly branches: boolean
+}
+
+interface Literal {
+  readonly line: number
+  /** Offsets of the opening quote and just past the closing one. */
+  readonly start: number
+  readonly end: number
+  /**
+   * The literal's text with `\n` decoded and each `${}` expression replaced by
+   * `INTERPOLATION`, so a line carrying one can be told from a static line.
+   */
+  readonly text: string
+}
+
+const INTERPOLATION = '\u0000'
+
+/** Characters after which a `/` opens a regular expression rather than divides. */
+const REGEX_PRECEDERS = new Set('(,=:[!&|?{};+-*%<>~^'.split(''))
+const REGEX_KEYWORDS =
+  /(?:^|[^\w$])(?:return|typeof|case|do|else|in|of|new|delete|void|throw|yield|await)$/
+
+/**
+ * Finds every string and template literal in a TypeScript source.
+ *
+ * A pattern over backticks reads a doc comment saying `then` as a script, so
+ * the stage needs literal bounds. A syntax tree would give them too, but
+ * `typescript` is a development dependency and this module ships inside the
+ * published CLI, so a lexer tracking comment, string, regex, and template
+ * state stands in for it.
+ */
+function lex(source: string): {
+  readonly literals: Literal[]
+  /** Each comment's start, keyed by the end of its text. */
+  readonly comments: ReadonlyMap<number, number>
+} {
+  const literals: Literal[] = []
+  const comments = new Map<number, number>()
+  // One entry per open template expression, holding its brace depth.
+  const expressions: number[] = []
+  // One entry per open template, holding its start line and static text.
+  const templates: { line: number; start: number; text: string }[] = []
+  let line = 1
+  let i = 0
+  let lastSignificant = ''
+
+  const readQuoted = (quote: string): void => {
+    const opening = line
+    const start = i
+    let text = ''
+    i++
+    while (i < source.length && source[i] !== quote && source[i] !== '\n') {
+      if (source[i] === '\\') {
+        text += source[i + 1] === 'n' ? '\n' : (source[i + 1] ?? '')
+        if (source[i + 1] === '\n') line++
+        i += 2
+        continue
+      }
+      text += source[i]
+      i++
+    }
+    i++
+    literals.push({ line: opening, start, end: i, text })
+  }
+
+  // Reads template text until the closing backtick or the next `${`.
+  const readTemplate = (): void => {
+    const current = templates[templates.length - 1]
+    if (current === undefined) return
+    while (i < source.length) {
+      const char = source[i]
+      if (char === '\\') {
+        current.text += source[i + 1] === 'n' ? '\n' : (source[i + 1] ?? '')
+        if (source[i + 1] === '\n') line++
+        i += 2
+        continue
+      }
+      if (char === '`') {
+        i++
+        templates.pop()
+        literals.push({
+          line: current.line,
+          start: current.start,
+          end: i,
+          text: current.text,
+        })
+        lastSignificant = '`'
+        return
+      }
+      if (char === '$' && source[i + 1] === '{') {
+        current.text += INTERPOLATION
+        i += 2
+        expressions.push(0)
+        lastSignificant = '{'
+        return
+      }
+      if (char === '\n') line++
+      current.text += char
+      i++
+    }
+  }
+
+  const readRegex = (): void => {
+    let inClass = false
+    i++
+    while (i < source.length && source[i] !== '\n') {
+      const char = source[i]
+      if (char === '\\') {
+        i += 2
+        continue
+      }
+      if (char === '[') inClass = true
+      else if (char === ']') inClass = false
+      else if (char === '/' && !inClass) break
+      i++
+    }
+    i++
+    while (i < source.length && /[a-z]/.test(source[i] ?? '')) i++
+    lastSignificant = 'a'
+  }
+
+  while (i < source.length) {
+    const char = source[i] ?? ''
+    const next = source[i + 1]
+
+    if (char === '\n') {
+      line++
+      i++
+      continue
+    }
+    if (char === '/' && next === '/') {
+      const start = i
+      while (i < source.length && source[i] !== '\n') i++
+      comments.set(start + source.slice(start, i).trimEnd().length, start)
+      continue
+    }
+    if (char === '/' && next === '*') {
+      const end = source.indexOf('*/', i + 2)
+      const stop = end === -1 ? source.length : end + 2
+      for (let k = i; k < stop; k++) if (source[k] === '\n') line++
+      comments.set(stop, i)
+      i = stop
+      continue
+    }
+    if (char === "'" || char === '"') {
+      readQuoted(char)
+      lastSignificant = char
+      continue
+    }
+    if (char === '`') {
+      templates.push({ line, start: i, text: '' })
+      i++
+      readTemplate()
+      continue
+    }
+    if (char === '/') {
+      const before = source.slice(Math.max(0, i - 12), i).trimEnd()
+      if (
+        lastSignificant === '' ||
+        REGEX_PRECEDERS.has(lastSignificant) ||
+        REGEX_KEYWORDS.test(before)
+      ) {
+        readRegex()
+        continue
+      }
+    }
+    if (expressions.length > 0) {
+      const depth = expressions.length - 1
+      if (char === '{') expressions[depth] = (expressions[depth] ?? 0) + 1
+      if (char === '}') {
+        if (expressions[depth] === 0) {
+          expressions.pop()
+          i++
+          readTemplate()
+          continue
+        }
+        expressions[depth] = (expressions[depth] ?? 0) - 1
+      }
+    }
+    if (!/\s/.test(char)) lastSignificant = /[\w$)\]]/.test(char) ? 'a' : char
+    i++
+  }
+
+  return { literals, comments }
+}
+
+const PAGE_OPENER = /^\s*<(?:!doctype|html|head|body)\b/i
+// An HTML element name, so markup in a format of the project's own, such as a
+// `<rule>` payload, is not read as a page.
+const MARKUP_LINE =
+  /^\s*<\/?(?:a|article|button|canvas|code|details|dialog|div|figure|footer|form|h[1-6]|header|iframe|img|input|label|li|link|main|meta|nav|ol|option|p|pre|script|section|select|span|style|summary|svg|table|td|template|textarea|th|title|tr|ul)[\s>/]/i
+const CLOSING_TAG = /<\/[a-z][\w-]*>/i
+const SELECTOR_LINE = /^\s*[^\s{}'"`/][^{}'"`;]*\{\s*$/
+const DECLARATION_LINE = /^\s*-{0,2}[a-z][a-z-]*\s*:\s*[^;{}]+;\s*$/
+const SHEBANG = /^\s*#!\//
+// Each opener needs its own keyword and closer, so prose that opens a line on
+// `for` and ends another on `done` is not read as a script.
+const SHELL_BRANCHES: readonly RegExp[] = [
+  /(?:^\s*|[;&|]\s*)(?:if|elif)\s[\s\S]*?\bthen\b[\s\S]*?(?:^|[;\s])fi\s*(?:$|[;)|&<>])/m,
+  /(?:^\s*|[;&|]\s*)(?:for|while|until)\s[\s\S]*?\bdo\b[\s\S]*?(?:^|[;\s])done\s*(?:$|[;)|&<>])/m,
+  /(?:^\s*|[;&|]\s*)case\s[\s\S]*?\bin\b[\s\S]*?(?:^|[;\s])esac\s*(?:$|[;)|&<>])/m,
+]
+const NEWLINE_JOIN = /^\]\s*\.join\(\s*(['"`])\\n\1\s*\)/
+
+/**
+ * Lines carrying content and no interpolation. A leading newline counts for
+ * nothing, and a line built from data is code generating output, so only the
+ * static part of a template is weighed against the limit.
+ */
+function staticLines(text: string): number {
+  return text
+    .split('\n')
+    .filter((line) => line.trim() !== '' && !line.includes(INTERPOLATION))
+    .length
+}
+
+/** The language a literal's static text is written in, or none of the three. */
+function kindOf(
+  text: string,
+): { kind: EmbeddedKind; branches: boolean } | undefined {
+  const branches = SHELL_BRANCHES.some((branch) => branch.test(text))
+  if (SHEBANG.test(text) || branches) return { kind: 'script', branches }
+  const lines = text.split('\n').filter((line) => line.trim() !== '')
+  if (
+    PAGE_OPENER.test(text) ||
+    (CLOSING_TAG.test(text) && MARKUP_LINE.test(lines[0] ?? ''))
+  ) {
+    return { kind: 'page', branches: false }
+  }
+  if (
+    lines.some((line) => SELECTOR_LINE.test(line)) &&
+    lines.some((line) => DECLARATION_LINE.test(line))
+  ) {
+    return { kind: 'stylesheet', branches: false }
+  }
+  return undefined
+}
+
+/** The offset of the next token, past whitespace and comments. */
+function skipTrivia(source: string, from: number): number {
+  let i = from
+  while (i < source.length) {
+    if (/\s/.test(source[i] ?? '')) {
+      i++
+    } else if (source.startsWith('//', i)) {
+      const end = source.indexOf('\n', i)
+      i = end === -1 ? source.length : end + 1
+    } else if (source.startsWith('/*', i)) {
+      const end = source.indexOf('*/', i + 2)
+      i = end === -1 ? source.length : end + 2
+    } else {
+      return i
+    }
+  }
+  return i
+}
+
+/**
+ * Merges each array of literals closed by a newline join into one block opening
+ * on the array's bracket, since a script written line by line is one program and
+ * each of its literals alone reads as nothing. An array holding anything but
+ * literals stays as its separate literals.
+ */
+function blocksOf(
+  source: string,
+  literals: readonly Literal[],
+  comments: ReadonlyMap<number, number>,
+): Literal[] {
+  // The offset of the last token before `from`, past whitespace and comments.
+  const tokenBefore = (from: number): number => {
+    let at = from
+    for (;;) {
+      while (at > 0 && /\s/.test(source[at - 1] ?? '')) at--
+      const start = comments.get(at)
+      if (start === undefined) return at - 1
+      at = start
+    }
+  }
+
+  const byStart = new Map(literals.map((literal) => [literal.start, literal]))
+  const merged = new Set<Literal>()
+  const blocks: Literal[] = []
+
+  for (const first of literals) {
+    if (merged.has(first)) continue
+    const bracket = tokenBefore(first.start)
+    if (source[bracket] !== '[') continue
+
+    const run: Literal[] = []
+    let next: Literal | undefined = first
+    let cursor = first.start
+    while (next !== undefined) {
+      run.push(next)
+      cursor = skipTrivia(source, next.end)
+      if (source[cursor] === ',') cursor = skipTrivia(source, cursor + 1)
+      next = byStart.get(cursor)
+    }
+    if (!NEWLINE_JOIN.test(source.slice(cursor, cursor + 40))) continue
+
+    for (const literal of run) merged.add(literal)
+    blocks.push({
+      line: source.slice(0, bracket).split('\n').length,
+      start: bracket,
+      end: cursor,
+      text: run.map((literal) => literal.text).join('\n'),
+    })
+  }
+
+  return [
+    ...blocks,
+    ...literals.filter((literal) => !merged.has(literal)),
+  ].sort((a, b) => a.start - b.start)
+}
+
+/**
+ * The pages, stylesheets, and scripts a source embeds past the limit, or a
+ * script that branches at any length.
+ *
+ * Only a template's static lines count, so a long page with one interpolation
+ * still counts and a block built line by line from data does not. A literal whose
+ * opening line, or the line above it, carries the marker with a reason is
+ * exempt, and a bare marker exempts nothing.
+ */
+export function embeddedBlocksIn(
+  file: string,
+  source: string,
+): EmbeddedBlock[] {
+  const sourceLines = source.split('\n')
+  const blocks: EmbeddedBlock[] = []
+  const { literals, comments } = lex(source)
+  for (const literal of blocksOf(source, literals, comments)) {
+    const found = kindOf(literal.text.replaceAll(INTERPOLATION, ''))
+    if (found === undefined) continue
+    const lines = staticLines(literal.text)
+    if (lines <= EMBEDDED_LINE_LIMIT && !found.branches) continue
+    if (isMarked(sourceLines, literal.line - 1, EMBEDDED_MARKER)) continue
+    blocks.push({ file, line: literal.line, lines, ...found })
+  }
+  return blocks
+}
+
+const SOURCE_FILE = /\.(?:ts|tsx|mts|cts)$/
+
+export const embeddedPrograms: Measure = async (ctx) => {
+  const files = await listRepositoryFiles(ctx.root)
+  if (files === undefined) {
+    return {
+      emissions: [],
+      unmeasured:
+        'The tracked file list could not be read, so no source was scanned for embedded blocks.',
+    }
+  }
+
+  const sources = files.filter((path) => SOURCE_FILE.test(path))
+  const blocks = sources.flatMap((path) =>
+    embeddedBlocksIn(path, readFileSync(join(ctx.root, path), 'utf8')),
+  )
+
+  if (blocks.length === 0) {
+    const emissions: Emission[] = [
+      {
+        kind: 'info',
+        text: `No page, stylesheet, or script embedded past ${EMBEDDED_LINE_LIMIT} lines across ${plural(sources.length, 'source file')}`,
+      },
+    ]
+    return { emissions }
+  }
+
+  return {
+    emissions: blocks.map((block) => ({
+      kind: 'warn',
+      text: `${block.file}:${block.line} embeds ${block.branches ? 'a branching script' : `a ${block.kind} of ${plural(block.lines, 'line')}`}`,
+    })),
+    failure: `${plural(blocks.length, 'embedded block')} past the limit. Move each into its own file with its language's extension, read from disk, or mark the opening line with "${EMBEDDED_MARKER}: <reason>" where it must stay inline.`,
+  }
+}

package/src/gate/stages.ts

@@ -5,6 +5,7 @@ import {
   seedIndependence,
   skillPaths,
 } from '@/gate/boundaries'
+import { embeddedPrograms } from '@/gate/embedded'
 import {
   canonicalRecords,
   auditSet,
@@ -366,6 +367,13 @@ export const STAGES: readonly Stage[] = [
     label: 'Folder-echoed filenames',
     checks: [{ kind: 'measure', measure: folderEchoedNames }],
   },
+  {
+    // Unscoped, since a block one branch embeds stays embedded on every later
+    // branch, and reading every tracked source costs well under a second.
+    id: 'embedded-programs',
+    label: 'Embedded programs',
+    checks: [{ kind: 'measure', measure: embeddedPrograms }],
+  },
   {
     // A rule citing a file that moved fails silently. The consumed-copy drift
     // stage passes an authored rule and its copy that are wrong together, and

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(' ')