explico 0.6.0 → 0.8.0

package/src/components/starlight/HeadingAnchorEnhancer.astro

@@ -37,6 +37,7 @@
 
 <script>
   import { HEADINGS, sectionParts } from './section-parts';
+  import { animatedScrollIntoView } from '../scroll-animation';
 
   (() => {
     const root = document.querySelector('.sl-markdown-content');
@@ -78,10 +79,7 @@
       if (!heading) return;
       const parts = sectionParts(heading);
       if (doScroll) {
-        parts[0].scrollIntoView({
-          behavior: reduce.matches ? 'auto' : 'smooth',
-          block: 'start',
-        });
+        animatedScrollIntoView(parts[0], { block: 'start' });
       }
       for (const part of parts) flash(part);
       heading.setAttribute('tabindex', '-1');

package/src/components/starlight/KeyedFloatEnhancer.astro

@@ -40,6 +40,8 @@
 ---
 
 <script>
+  import { animatedScrollIntoView } from '../scroll-animation';
+
   (() => {
     const root = document.querySelector('.sl-markdown-content');
     if (!root) return;
@@ -97,10 +99,7 @@
         target.style.removeProperty('animation');
       }
       if (doScroll) {
-        target.scrollIntoView({
-          behavior: reduce.matches ? 'auto' : 'smooth',
-          block: 'start',
-        });
+        animatedScrollIntoView(target, { block: 'start' });
       }
       target.setAttribute('tabindex', '-1');
       try {
@@ -132,13 +131,15 @@
 
     // "Copy LaTeX" for an equation, two ways: its own button (only a numbered
     // display equation has one — `data-eq-copy`, `remark-notation.mjs`'s
-    // `equationNode`), or a click anywhere else in the equation that isn't a
-    // symbol with its own notation card (an operator, a bare number, a
-    // parenthesis, …) — the same gesture works on an inline equation too
-    // (`inlineEquationNode`), which has no room for a persistent button of
-    // its own without breaking the reading line. A notation-registry symbol
-    // keeps its existing click-to-pin behavior either way
-    // (`NotationLayer.astro`), so this skips anything under `[data-notation-key]`.
+    // `equationNode`), or a click anywhere else in the box — including the
+    // reserved gutter between the equation and its number/button, not just
+    // the rendered `.katex-html` — that isn't the number link or a symbol
+    // with its own notation card. The same gesture works on an inline
+    // equation too (`inlineEquationNode`), which has no room for a
+    // persistent button of its own without breaking the reading line. A
+    // notation-registry symbol keeps its existing click-to-pin behavior
+    // either way (`NotationLayer.astro`), so this skips anything under
+    // `[data-notation-key]`.
     root.addEventListener('click', (event) => {
       const origin = event.target instanceof Element ? event.target : null;
       if (!origin) return;
@@ -150,9 +151,7 @@
       const container = ownButton
         ? null
         : origin.closest<HTMLElement>('.keyed-equation, .inline-equation');
-      if (!ownButton && (!container || !origin.closest('.katex-html'))) {
-        return;
-      }
+      if (!ownButton && !container) return;
 
       const feedbackTarget =
         ownButton ??
@@ -185,12 +184,14 @@
     root.addEventListener('mouseover', (event) => {
       const origin = event.target instanceof Element ? event.target : null;
       if (!origin || origin.getAttribute('title') === 'Copy LaTeX') return;
-      if (origin.closest('[data-notation-key], [data-eq-copy]')) return;
       if (
-        !origin.closest('.keyed-equation .katex-html, .inline-equation .katex-html')
+        origin.closest(
+          '[data-notation-key], [data-eq-copy], a.keyed-equation__number',
+        )
       ) {
         return;
       }
+      if (!origin.closest('.keyed-equation, .inline-equation')) return;
       origin.setAttribute('title', 'Copy LaTeX');
     });
 

package/src/components/starlight/LessonFooter.astro

@@ -23,6 +23,7 @@ import AbbreviationLayer from '../abbreviation/AbbreviationLayer.astro';
 import KeyedFloatEnhancer from './KeyedFloatEnhancer.astro';
 import FloatRefLayer from '../reference/FloatRefLayer.astro';
 import HeadingAnchorEnhancer from './HeadingAnchorEnhancer.astro';
+import AnchorScrollEnhancer from './AnchorScrollEnhancer.astro';
 import CollapsibleSections from './CollapsibleSections.astro';
 import TableOverflowExpander from '../table/TableOverflowExpander.astro';
 import DiagramEnhancer from './DiagramEnhancer.astro';
@@ -83,6 +84,7 @@ if (lessonId) {
 ---
 
 <NotationLayer definitions={definitions} defaultOpen={notationDefaultOpen} />
+<AnchorScrollEnhancer />
 {lessonId && <CitationLayer />}
 {lessonId && <AbbreviationLayer />}
 {lessonId && <KeyedFloatEnhancer />}

package/src/reference/base-abbreviations.mjs

@@ -20,12 +20,18 @@ export const BASE_ABBREVIATIONS = Object.freeze(
     'e.g.',
     'i.e.',
     'etc.',
+    'e.t.c.',
     'cf.',
     'vs.',
-    'a.m.',
-    'p.m.',
     'a.k.a.',
     'et al.',
+    // time of day, in each casing/punctuation style a lesson might use
+    'a.m.',
+    'p.m.',
+    'A.M.',
+    'P.M.',
+    'AM',
+    'PM',
     // generic acronyms with no domain-specific meaning in this engine
     'AI',
     'ID',

package/src/reference/consistency.ts

@@ -2,11 +2,11 @@
  * Corpus consistency checks (Step D6) — the Tier 1–2 checks from the cleanup
  * plan's "Enforced checks" section that no earlier step covers.
  *
- * Every check here enters as a **Tier-3 warning**: `pnpm validate:content`
- * surfaces the counts, `manifest.diagnostics.consistency` records the detail,
- * and `resolution/consistency-report.json` is the committed, diff-checkable
- * snapshot. Nothing here changes content — each finding is an open item for a
- * separate human-quantitative-reviewed pass. A finding is silenced only by a
+ * Every check here is non-blocking Tier 3: repairable violations are warnings
+ * and optional restructuring advice is info. `pnpm validate:content` surfaces
+ * warning counts, `manifest.diagnostics.consistency` records every detail, and
+ * `resolution/consistency-report.json` is the committed, diff-checkable
+ * snapshot. Nothing here changes content. A finding is silenced only by a
  * reviewed line in `lint-ignore.yml` (see `./lint-ignore`).
  *
  *   (a) glyph-unique-in-corpus       one rendered glyph → one meaning corpus-wide
@@ -14,8 +14,6 @@
  *                                     unit strings drawn from a controlled vocab
  *   (c) convention-single-definition  a sign / cash-flow-perspective convention a
  *                                     lesson uses resolves to one declaration
- *   (e) numerals-tagged              numerals in `$…$` / result tables are tagged
- *                                     to a `src/domain/` call or a source locator
  *   (f) weak-local                   a `notation.local` symbol used only in its
  *                                     own defining equation and prose
  *   (g) notation-source-locator      every notation `sources` entry has a locator
@@ -54,7 +52,6 @@ export type ConsistencyCode =
   | 'notation-units'
   | 'units-vocab'
   | 'convention-single-definition'
-  | 'numerals-tagged'
   | 'weak-local'
   | 'notation-source-locator'
   | 'gloss-wants-promoting'
@@ -65,8 +62,8 @@ export type ConsistencyCode =
 
 export interface ConsistencyDiagnostic {
   readonly code: ConsistencyCode;
-  /** Tier 3 — every finding here is a warning until content is brought clean. */
-  readonly severity: 'warning';
+  /** Tier 3 — repairable violations are warnings; optional advice is info. */
+  readonly severity: 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;
@@ -119,28 +116,6 @@ function mathSpans(body: string): MathSpan[] {
   return spans;
 }
 
-function tableRows(body: string): string[] {
-  const rows: string[] = [];
-  for (const line of stripCode(body).split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('|') || !trimmed.slice(1).includes('|')) continue;
-    if (/^\s*\|[\s:|-]+\|\s*$/.test(line)) continue;
-    rows.push(line);
-  }
-  return rows;
-}
-
-const NUMERAL_RE = /(?<![\w.])-?\d+(?:\.\d+)?/g;
-
-function numeralCount(text: string): number {
-  return (text.replace(/\\[a-zA-Z]+/g, ' ').match(NUMERAL_RE) ?? []).length;
-}
-
-/** A math span / table row is "tagged" when it carries a citation or a domain marker. */
-function isTagged(text: string): boolean {
-  return /\[@[a-z0-9]/i.test(text) || /<!--\s*domain:/i.test(text);
-}
-
 // --- glyph regex for weak-local --------------------------------------
 
 function glyphMatcher(latex: string): RegExp | undefined {
@@ -274,35 +249,6 @@ function checkConventionSingleDefinition(
   }
 }
 
-function checkNumeralsTagged(
-  input: ConsistencyInput,
-  out: ConsistencyDiagnostic[],
-): void {
-  for (const lesson of input.notationInput.lessons) {
-    if (input.lintIgnore.matches('numerals-tagged', lesson.lessonId)) continue;
-    let math = 0;
-    for (const span of mathSpans(lesson.body)) {
-      if (isTagged(span.latex)) continue;
-      math += numeralCount(span.latex);
-    }
-    let table = 0;
-    for (const row of tableRows(lesson.body)) {
-      if (isTagged(row)) continue;
-      table += numeralCount(row.replace(/\$[^$\n]*\$/g, ' '));
-    }
-    const count = math + table;
-    if (count === 0) continue;
-    out.push({
-      code: 'numerals-tagged',
-      severity: 'warning',
-      lessonId: lesson.lessonId,
-      file: lesson.source.file,
-      count,
-      message: `${lesson.lessonId}: ${count} numeral(s) in $…$ / result tables (${math} in math, ${table} in tables) are not tagged to a src/domain/ call or a source locator`,
-    });
-  }
-}
-
 function checkWeakLocal(
   input: ConsistencyInput,
   out: ConsistencyDiagnostic[],
@@ -317,7 +263,7 @@ function checkWeakLocal(
       if (uses > 1) continue;
       out.push({
         code: 'weak-local',
-        severity: 'warning',
+        severity: 'info',
         lessonId: lesson.lessonId,
         file: lesson.source.file,
         key: definition.key,
@@ -390,7 +336,7 @@ function checkGlossWantsPromoting(
     if (input.lintIgnore.matches('gloss-wants-promoting', glyph)) continue;
     out.push({
       code: 'gloss-wants-promoting',
-      severity: 'warning',
+      severity: 'info',
       glyph,
       message: `gloss ${JSON.stringify(glyph)} (${label}) is declared on ${keys.size} entries (${[...keys].sort().join(', ')}); a meaning reused this widely wants promoting to a card`,
     });
@@ -425,7 +371,7 @@ function checkCardWantsDemoting(
     }
     out.push({
       code: 'card-wants-demoting',
-      severity: 'warning',
+      severity: 'info',
       key: definition.key,
       file: definition.source.file,
       count: words,
@@ -627,7 +573,6 @@ const CHECKS: ((
   checkGlyphUniqueness,
   checkNotationUnits,
   checkConventionSingleDefinition,
-  checkNumeralsTagged,
   checkWeakLocal,
   checkNotationSourceLocator,
   checkGlossWantsPromoting,
@@ -666,7 +611,6 @@ export function consistencyCounts(
     'notation-units': 0,
     'units-vocab': 0,
     'convention-single-definition': 0,
-    'numerals-tagged': 0,
     'weak-local': 0,
     'notation-source-locator': 0,
     'gloss-wants-promoting': 0,

package/src/reference/delimiter-size.ts

@@ -0,0 +1,279 @@
+/**
+ * Rule N17: a nested scalable delimiter is sized by the engine, never by hand.
+ *
+ * The engine installs a KaTeX whose `\delimitershortfall` is `-1pt`
+ * (`katex-delimiters.mjs`), so a `\left`/`\right` pair is always
+ * strictly taller than what it wraps. Nesting depth therefore shows up on its
+ * own, and a hand-picked `\bigl`…`\Biggr` inside a nest only replaces a size
+ * that tracks the content with a fixed glyph that does not.
+ *
+ * This deliberately parses only sizing syntax. It does not decide whether a
+ * parenthesis, bracket, or brace is semantic, and it never recommends changing
+ * one delimiter shape into another. N16's alternating-shape preference remains
+ * a review-only authoring concern.
+ */
+
+export const DELIMITER_SIZE_DIAGNOSTIC_CODE = 'delimiter-manual-size' as const;
+
+export type DelimiterSizeName =
+  | 'automatic'
+  | 'big'
+  | 'Big'
+  | 'bigg'
+  | 'Bigg';
+
+export interface DelimiterSizeSuggestion {
+  readonly open: string;
+  readonly close: string;
+  readonly latex: string;
+}
+
+export interface DelimiterSizeDiagnostic {
+  readonly code: typeof DELIMITER_SIZE_DIAGNOSTIC_CODE;
+  readonly severity: 'warning';
+  readonly offset: number;
+  readonly line: number;
+  readonly column: number;
+  /** The hand-picked size that should become `\left`/`\right`. */
+  readonly size: Exclude<DelimiterSizeName, 'automatic'>;
+  readonly suggestion: DelimiterSizeSuggestion;
+  readonly message: string;
+}
+
+type TokenKind = 'open' | 'close';
+type PairKind = 'automatic' | 'manual';
+
+interface SizeSpec {
+  readonly name: DelimiterSizeName;
+  /** `\left` and `\big` can be visually equivalent, so share level 1. */
+  readonly rank: number;
+  readonly openCommand: string;
+  readonly closeCommand: string;
+  readonly kind: PairKind;
+}
+
+interface DelimiterToken {
+  readonly kind: TokenKind;
+  readonly pairKind: PairKind;
+  readonly rank: number;
+  readonly size: DelimiterSizeName;
+  readonly delimiter: string;
+  readonly offset: number;
+  readonly end: number;
+}
+
+interface DelimiterPair {
+  readonly open: DelimiterToken;
+  close?: DelimiterToken;
+  readonly children: DelimiterPair[];
+}
+
+const SIZE_SPECS: readonly SizeSpec[] = [
+  {
+    name: 'automatic',
+    rank: 1,
+    openCommand: '\\left',
+    closeCommand: '\\right',
+    kind: 'automatic',
+  },
+  {
+    name: 'big',
+    rank: 1,
+    openCommand: '\\bigl',
+    closeCommand: '\\bigr',
+    kind: 'manual',
+  },
+  {
+    name: 'Big',
+    rank: 2,
+    openCommand: '\\Bigl',
+    closeCommand: '\\Bigr',
+    kind: 'manual',
+  },
+  {
+    name: 'bigg',
+    rank: 3,
+    openCommand: '\\biggl',
+    closeCommand: '\\biggr',
+    kind: 'manual',
+  },
+  {
+    name: 'Bigg',
+    rank: 4,
+    openCommand: '\\Biggl',
+    closeCommand: '\\Biggr',
+    kind: 'manual',
+  },
+];
+
+interface CommandSpec extends SizeSpec {
+  readonly command: string;
+  readonly tokenKind: TokenKind;
+}
+
+// Longest first prevents `\Biggl` from being considered as `\Bigl`.
+const COMMAND_SPECS: readonly CommandSpec[] = SIZE_SPECS.flatMap((spec) => [
+  { ...spec, command: spec.openCommand, tokenKind: 'open' as const },
+  { ...spec, command: spec.closeCommand, tokenKind: 'close' as const },
+]).sort((left, right) => right.command.length - left.command.length);
+
+function delimiterAt(
+  latex: string,
+  offset: number,
+  kind: TokenKind,
+): { delimiter: string; end: number } | undefined {
+  const candidates =
+    kind === 'open'
+      ? (['\\{', '(', '['] as const)
+      : (['\\}', ')', ']'] as const);
+  for (const delimiter of candidates) {
+    if (latex.startsWith(delimiter, offset)) {
+      return { delimiter, end: offset + delimiter.length };
+    }
+  }
+  return undefined;
+}
+
+function tokenAt(latex: string, offset: number): DelimiterToken | undefined {
+  if (latex[offset] !== '\\') return undefined;
+  for (const spec of COMMAND_SPECS) {
+    if (!latex.startsWith(spec.command, offset)) continue;
+    const afterCommand = offset + spec.command.length;
+    // A longer control word such as `\leftarrow` is not `\left`.
+    if (/[A-Za-z]/.test(latex[afterCommand] ?? '')) continue;
+    let delimiterOffset = afterCommand;
+    while (/\s/.test(latex[delimiterOffset] ?? '')) delimiterOffset += 1;
+    const delimiter = delimiterAt(latex, delimiterOffset, spec.tokenKind);
+    if (!delimiter) continue;
+    return {
+      kind: spec.tokenKind,
+      pairKind: spec.kind,
+      rank: spec.rank,
+      size: spec.name,
+      delimiter: delimiter.delimiter,
+      offset,
+      end: delimiter.end,
+    };
+  }
+  return undefined;
+}
+
+function pairMatches(open: DelimiterToken, close: DelimiterToken): boolean {
+  return (
+    open.kind === 'open' &&
+    close.kind === 'close' &&
+    open.pairKind === close.pairKind &&
+    open.rank === close.rank
+  );
+}
+
+function isEscaped(latex: string, offset: number): boolean {
+  let slashes = 0;
+  for (let index = offset - 1; index >= 0 && latex[index] === '\\'; index -= 1) {
+    slashes += 1;
+  }
+  return slashes % 2 === 1;
+}
+
+/**
+ * Build a real nesting tree using an explicit stack. Malformed input is left
+ * to KaTeX's syntax diagnostics; this linter emits no potentially misleading
+ * size advice for a source whose pairs cannot be matched reliably.
+ */
+function parseDelimiterPairs(latex: string): DelimiterPair[] | undefined {
+  const roots: DelimiterPair[] = [];
+  const stack: DelimiterPair[] = [];
+
+  for (let offset = 0; offset < latex.length; offset += 1) {
+    if (latex[offset] === '%' && !isEscaped(latex, offset)) {
+      const newline = latex.indexOf('\n', offset + 1);
+      if (newline === -1) break;
+      offset = newline;
+      continue;
+    }
+    const token = isEscaped(latex, offset) ? undefined : tokenAt(latex, offset);
+    if (!token) continue;
+    offset = token.end - 1;
+
+    if (token.kind === 'open') {
+      const pair: DelimiterPair = { open: token, children: [] };
+      const parent = stack[stack.length - 1];
+      if (parent) parent.children.push(pair);
+      else roots.push(pair);
+      stack.push(pair);
+      continue;
+    }
+
+    const pair = stack[stack.length - 1];
+    if (!pair || !pairMatches(pair.open, token)) return undefined;
+    pair.close = token;
+    stack.pop();
+  }
+
+  return stack.length === 0 ? roots : undefined;
+}
+
+function lineAndColumn(
+  source: string,
+  offset: number,
+): { line: number; column: number } {
+  const before = source.slice(0, offset);
+  const lastNewline = before.lastIndexOf('\n');
+  return {
+    line: before.split('\n').length,
+    column: offset - lastNewline,
+  };
+}
+
+const SPEC_BY_SIZE = new Map(SIZE_SPECS.map((spec) => [spec.name, spec]));
+
+function suggestionFor(pair: DelimiterPair): DelimiterSizeSuggestion {
+  const open = `\\left${pair.open.delimiter}`;
+  const close = `\\right${pair.close?.delimiter ?? pair.open.delimiter}`;
+  return { open, close, latex: `${open} ... ${close}` };
+}
+
+/**
+ * Warn when a pair that takes part in a nest of scalable delimiters is sized
+ * by hand instead of by `\left`/`\right`.
+ *
+ * A pair takes part in a nest when it contains, or sits inside, another pair
+ * this linter tracks. A lone hand-sized pair around otherwise bare content —
+ * `\bigl(x(t),\ y(t)\bigr)` for a tuple — is a deliberate typographic
+ * choice at a single level, has no hierarchy to get wrong, and is left alone.
+ *
+ * Only `()`, `[]`, and `\{\}` are parsed. Bare delimiters are intentionally
+ * ignored: N15 owns that separate error, while ordinary semantic notation
+ * such as `f(x)` and `\mathbb{E}[X]` must not trigger this size-only linter.
+ */
+export function lintDelimiterSizes(latex: string): DelimiterSizeDiagnostic[] {
+  const roots = parseDelimiterPairs(latex);
+  if (!roots) return [];
+  const diagnostics: DelimiterSizeDiagnostic[] = [];
+
+  const visit = (pair: DelimiterPair, nested: boolean): void => {
+    const inNest = nested || pair.children.length > 0;
+    if (inNest && pair.open.pairKind === 'manual') {
+      const location = lineAndColumn(latex, pair.open.offset);
+      const suggestion = suggestionFor(pair);
+      diagnostics.push({
+        code: DELIMITER_SIZE_DIAGNOSTIC_CODE,
+        severity: 'warning',
+        offset: pair.open.offset,
+        ...location,
+        size: pair.open.size as Exclude<DelimiterSizeName, 'automatic'>,
+        suggestion,
+        message:
+          `A nested delimiter pair is sized by hand with ` +
+          `${SPEC_BY_SIZE.get(pair.open.size)?.openCommand ?? pair.open.size}` +
+          `${pair.open.delimiter}. Use ` +
+          `${suggestion.latex} and let the engine size the nest; preserve the ` +
+          `original opening and closing delimiter shapes (rule N17).`,
+      });
+    }
+    for (const child of pair.children) visit(child, true);
+  };
+
+  for (const root of roots) visit(root, false);
+  return diagnostics.sort((left, right) => left.offset - right.offset);
+}

package/src/reference/diagrams-validate.ts

@@ -15,7 +15,7 @@ export type DiagramDiagnosticCode =
 
 export interface DiagramDiagnostic {
   readonly code: DiagramDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;

package/src/reference/equations-validate.ts

@@ -4,7 +4,7 @@
  * - `eq-duplicate-key` (Tier 1, error): an `eq:` key is unique per lesson.
  * - `eq-ref-resolves` (Tier 1, error): every `[[eq-key]]` / `[[slug#eq-key]]`
  *   points at a display equation that carries `\label{eq:key}`.
- * - `eq-key-unused` (Tier 3, warning): a labelled equation never referenced.
+ * - `eq-key-unused` (info): a labelled equation is never referenced.
  *
  * The remark pass enforces the same rules on the render path; this gives the
  * fast `pnpm validate:content` the same coverage and feeds the manifest.
@@ -33,7 +33,7 @@ export type EquationDiagnosticCode =
 
 export interface EquationDiagnostic {
   readonly code: EquationDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;
@@ -154,7 +154,7 @@ export function validateEquations(
     if (referenced.has(`${label.slug}#${label.key}`)) continue;
     diagnostics.push({
       code: 'eq-key-unused',
-      severity: 'warning',
+      severity: 'info',
       message: `${label.lessonId} labels eq:${label.key} (${label.number}) but nothing references it with [[eq-${label.key}]]`,
       file: label.slug,
       lessonId: label.lessonId,

package/src/reference/equations.mjs

@@ -106,7 +106,13 @@ export function displayEquationNumber({
     : `${prefix}.${offset + indexInLesson}`;
 }
 
-/** The positional anchor id for an unkeyed equation, e.g. `2.4` → `eq-2-4`. */
+/**
+ * A display equation's anchor id: `eq-<key>` when it carries a
+ * `\label{eq:…}`, else the positional form, e.g. `2.4` → `eq-2-4`.
+ *
+ * @param {{ key?: string, number?: string | number }} equation - `number` is
+ *   read only when there is no `key`, so a keyed caller may omit it.
+ */
 export function equationAnchorId({ key, number }) {
   return key ? `eq-${key}` : `eq-${String(number).replace(/\./g, '-')}`;
 }

package/src/reference/figures-validate.ts

@@ -15,7 +15,7 @@ export type FigureDiagnosticCode =
 
 export interface FigureDiagnostic {
   readonly code: FigureDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;

package/src/reference/gate-abbreviations.ts

@@ -25,7 +25,7 @@ import { collectOperators, collectRomanLabels } from './math-glyphs.mjs';
 import { isBaseAbbreviation } from './base-abbreviations.mjs';
 import { pageScope } from './gate-math';
 import type { MathGateDiagnostic, ScopeEntry } from './gate-math';
-import { lineOf, proseOnly } from './gate-prose-notation';
+import { lessonLine, proseOnly } from './gate-prose-notation';
 import type {
   AbbreviationDefinitionInput,
   NotationRegistryInput,
@@ -117,7 +117,7 @@ export function gateAbbreviations(input: {
         context: 'abbreviation',
         severity: 'error',
         file: lesson.source.file,
-        line: lineOf(lesson.body, index),
+        line: lessonLine(lesson, index),
         token,
         message: `Unexplained abbreviation ${JSON.stringify(token)} outside math. ${FIX}`,
       });

package/src/reference/gate-heading-length.ts

@@ -21,7 +21,7 @@
  */
 import { stripFencedCode } from './equations.mjs';
 import type { MathGateDiagnostic } from './gate-math';
-import { lineOf } from './gate-prose-notation';
+import { lessonLine } from './gate-prose-notation';
 import type { NotationLessonInput } from './types';
 
 export const HEADING_LENGTH_LIMIT = 65;
@@ -120,7 +120,7 @@ export function gateHeadingLength(
         context: 'structure',
         severity: 'error',
         file: lesson.source.file,
-        line: lineOf(lesson.body, finding.index),
+        line: lessonLine(lesson, finding.index),
         token: finding.token,
         message: finding.message,
       });