explico 0.7.0 → 0.11.0

package/dist/reference/gate-heading-length.js

@@ -1,71 +1,95 @@
-import { stripFencedCode } from "./equations.mjs";
-import { lineOf } from "./gate-prose-notation.js";
+import { EQ_CAPTION_PATTERN, stripFencedCode } from "./equations.mjs";
+import { stripHeadingMarker } from "./rehype-heading-anchors.mjs";
+import { lessonLine } from "./gate-prose-notation.js";
 const HEADING_LENGTH_LIMIT = 65;
 const HEADING_LINE = /^[ \t]{0,3}(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/gm;
-const TITLE_ATTRIBUTE_BY_TAG = {
-  Figure: "title",
-  Diagram: "label",
-  Memo: "title",
+const SHORT_ATTRIBUTE_BY_TAG = {
+  Figure: "short",
+  Diagram: "short",
+  Table: "short",
+  Memo: "short",
+  CompactExamples: "short",
   ShortNote: "title"
 };
+const DISPLAY_MATH = /\$\$([\s\S]+?)\$\$/g;
 function readAttribute(attributesSource, name) {
   const pattern = new RegExp(`\\b${name}\\s*=\\s*(["'])([^"']*)\\1`);
   const match = pattern.exec(attributesSource);
   return match ? match[2] : void 0;
 }
-function overLimitMessage(kind, text) {
-  return `${kind} ${JSON.stringify(text)} is ${text.length} characters, over the ${HEADING_LENGTH_LIMIT}-character limit (rule S1). Shorten it and move the rest into the paragraph or caption that follows.`;
+function overLimitMessage(kind, text, limit) {
+  return `${kind} ${JSON.stringify(text)} is ${text.length} characters, over the ${limit}-character limit (rule S1, rules.S1.maxLength in the course settings). Shorten it and move the rest into the paragraph or caption that follows.`;
 }
-function headingFindings(text) {
+function headingFindings(text, limit) {
   const out = [];
   const re = new RegExp(HEADING_LINE.source, HEADING_LINE.flags);
   let match;
   while (match = re.exec(text)) {
     const level = match[1]?.length ?? 1;
-    const title = (match[2] ?? "").trim();
-    if (title.length > HEADING_LENGTH_LIMIT) {
+    const title = stripHeadingMarker(match[2] ?? "").trim();
+    if (title.length > limit) {
       out.push({
         index: match.index,
         token: title,
-        message: overLimitMessage(`${"#".repeat(level)} heading`, title)
+        message: overLimitMessage(`${"#".repeat(level)} heading`, title, limit)
       });
     }
   }
   return out;
 }
-function floatTitleFindings(text) {
+function floatTitleFindings(text, limit) {
   const out = [];
-  for (const [tagName, attribute] of Object.entries(TITLE_ATTRIBUTE_BY_TAG)) {
+  for (const [tagName, attribute] of Object.entries(SHORT_ATTRIBUTE_BY_TAG)) {
     const opening = new RegExp(`<${tagName}\\b([^>]*)>`, "g");
     let match;
     while (match = opening.exec(text)) {
       const value = readAttribute(match[1] ?? "", attribute)?.trim();
-      if (value && value.length > HEADING_LENGTH_LIMIT) {
+      if (value && value.length > limit) {
         out.push({
           index: match.index,
           token: value,
-          message: overLimitMessage(`<${tagName} ${attribute}>`, value)
+          message: overLimitMessage(`<${tagName} ${attribute}>`, value, limit)
         });
       }
     }
   }
   return out;
 }
-function findingsIn(text) {
-  return [...headingFindings(text), ...floatTitleFindings(text)].sort(
-    (a, b) => a.index - b.index
-  );
+function equationCaptionFindings(text, limit) {
+  const out = [];
+  for (const display of text.matchAll(DISPLAY_MATH)) {
+    for (const caption of (display[1] ?? "").matchAll(EQ_CAPTION_PATTERN)) {
+      const value = (caption[1] ?? "").replace(/\s+/g, " ").trim();
+      if (value.length > limit) {
+        out.push({
+          index: (display.index ?? 0) + 2 + (caption.index ?? 0),
+          token: value,
+          message: overLimitMessage("Equation \\caption{}", value, limit)
+        });
+      }
+    }
+  }
+  return out;
+}
+function findingsIn(text, limit) {
+  return [
+    ...headingFindings(text, limit),
+    ...floatTitleFindings(text, limit),
+    ...equationCaptionFindings(text, limit)
+  ].sort((a, b) => a.index - b.index);
 }
-function gateHeadingLength(lessons) {
+function gateHeadingLength(lessons, options = {}) {
   const diagnostics = [];
+  const limit = options.maxLength ?? HEADING_LENGTH_LIMIT;
   for (const lesson of lessons) {
     const text = stripFencedCode(lesson.body);
-    for (const finding of findingsIn(text)) {
+    for (const finding of findingsIn(text, limit)) {
       diagnostics.push({
         context: "structure",
+        code: "title-length",
         severity: "error",
         file: lesson.source.file,
-        line: lineOf(lesson.body, finding.index),
+        line: lessonLine(lesson, finding.index),
         token: finding.token,
         message: finding.message
       });

package/dist/reference/gate-heading-structure.d.ts

@@ -0,0 +1,41 @@
+import { MathGateDiagnostic } from './gate-math.js';
+import { NotationLessonInput } from './types.js';
+
+/**
+ * The heading-structure gate: rules S6 and S7, over a lesson's outline — the
+ * top-level headings `sections.mjs` numbers, read by the same
+ * `scanOutlineBlocks`, so the rules and the section numbers can never
+ * disagree about which headings a page has. A heading inside a component
+ * (`<Memo>`, `<CompactExample>`, …) belongs to that component and is in
+ * neither. See docs/authoring/structure-rules.md#s6 and #s7.
+ *
+ * - **S6 (`heading-skip`)** — headings descend one level at a time. The page
+ *   title (`frontmatter.title`) is the lesson's one `#`, so the body starts at
+ *   `##`, a `#` in the body is an error, and a heading is at most one level
+ *   deeper than the one before it. Going back up any number of levels is fine.
+ * - **S7 (`heading-adjacent`)** — a heading is followed by body content,
+ *   never directly by another heading, whatever the two levels.
+ *
+ * Both also see the headings a component draws where its tag stands
+ * ({@link TITLED_COMPONENTS}): a knowledge check's and a worked-example set's
+ * `<h2>` (`BlockHeading.astro`) read as a `##`, so a heading written directly
+ * above either is two headings in a row, and the next heading steps from
+ * `##`.
+ *
+ * Ships straight as an error, same as S1: every playground violation was fixed
+ * or waived in the same change.
+ */
+
+/**
+ * Scan every lesson body's outline for rule S6 (`heading-skip`) and rule S7
+ * (`heading-adjacent`) findings. `levels` / `adjacency` switch each rule's
+ * half off, the way `rules.S6.enabled` / `rules.S7.enabled` do. Returns one
+ * `MathGateDiagnostic` (context `'structure'`, always an error) per finding,
+ * located at the heading that breaks the rule.
+ */
+declare function gateHeadingStructure(lessons: readonly NotationLessonInput[], options?: {
+    readonly levels?: boolean;
+    readonly adjacency?: boolean;
+}): MathGateDiagnostic[];
+
+export { gateHeadingStructure };

package/dist/reference/gate-heading-structure.js

@@ -0,0 +1,113 @@
+import { lessonLine } from "./gate-prose-notation.js";
+import { scanOutlineBlocks } from "./sections.mjs";
+const TITLED_COMPONENTS = {
+  AssessmentSet: {
+    level: 2,
+    what: "which renders its own `<h2>`: the \u201CKnowledge check\u201D badge, its number and the check\u2019s title"
+  },
+  CompactExamples: {
+    level: 2,
+    what: "which renders its own `<h2>`: the \u201CExample\u201D badge, its number and the set\u2019s `short` title"
+  }
+};
+function blocksOf(body) {
+  return scanOutlineBlocks(body).map((block) => {
+    if (block.kind === "heading") {
+      const hashes = "#".repeat(block.level);
+      return {
+        kind: "heading",
+        level: block.level,
+        label: `\`${hashes} ${block.text}\``,
+        token: block.text,
+        index: block.index
+      };
+    }
+    if (block.kind === "element") {
+      const titled = TITLED_COMPONENTS[block.name];
+      if (titled) {
+        return {
+          kind: "titled",
+          name: block.name,
+          index: block.index,
+          ...titled.level === void 0 ? {} : { level: titled.level }
+        };
+      }
+    }
+    return { kind: "content" };
+  });
+}
+function skipFindings(blocks) {
+  const out = [];
+  let previous = { level: 1, label: "the page title (`#`)" };
+  for (const block of blocks) {
+    if (block.kind === "content") continue;
+    if (block.kind === "titled") {
+      if (block.level !== void 0) {
+        previous = { level: block.level, label: `the \`<h${block.level}>\` of \`<${block.name} />\`` };
+      }
+      continue;
+    }
+    if (block.level === 1) {
+      out.push({
+        code: "heading-skip",
+        index: block.index,
+        token: block.token,
+        message: `${block.label} is a \`#\` in the lesson body, but the page title (\`frontmatter.title\`) is the lesson\u2019s one \`#\`: the body\u2019s headings start at \`##\` (rule S6). Make it \`##\`, or move the text into the title.`
+      });
+    } else if (block.level > previous.level + 1) {
+      const expected = "#".repeat(previous.level + 1);
+      out.push({
+        code: "heading-skip",
+        index: block.index,
+        token: block.token,
+        message: `${block.label} follows ${previous.label}, skipping a level: headings descend one level at a time (rule S6). Make it \`${expected}\`, or add the \`${expected}\` section it belongs under.`
+      });
+    }
+    previous = { level: block.level, label: block.label };
+  }
+  return out;
+}
+function adjacentFindings(blocks, lesson) {
+  const out = [];
+  blocks.forEach((block, position) => {
+    if (block.kind !== "heading") return;
+    const next = blocks[position + 1];
+    if (next === void 0 || next.kind === "content") return;
+    const line = lessonLine(lesson, next.index);
+    const followedBy = next.kind === "heading" ? `${next.label} (line ${line})` : `\`<${next.name}>\` (line ${line}), ${TITLED_COMPONENTS[next.name].what}`;
+    out.push({
+      code: "heading-adjacent",
+      index: block.index,
+      token: block.token,
+      message: `${block.label} is followed directly by ${followedBy}: a heading is followed by body content, never by another heading (rule S7). Write what the section is about before it goes on, or drop the heading that says nothing of its own.`
+    });
+  });
+  return out;
+}
+function gateHeadingStructure(lessons, options = {}) {
+  const { levels = true, adjacency = true } = options;
+  const diagnostics = [];
+  if (!levels && !adjacency) return diagnostics;
+  for (const lesson of lessons) {
+    const blocks = blocksOf(lesson.body);
+    const findings = [
+      ...levels ? skipFindings(blocks) : [],
+      ...adjacency ? adjacentFindings(blocks, lesson) : []
+    ].sort((a, b) => a.index - b.index);
+    for (const finding of findings) {
+      diagnostics.push({
+        context: "structure",
+        code: finding.code,
+        severity: "error",
+        file: lesson.source.file,
+        line: lessonLine(lesson, finding.index),
+        token: finding.token,
+        message: finding.message
+      });
+    }
+  }
+  return diagnostics;
+}
+export {
+  gateHeadingStructure
+};

package/dist/reference/gate-math-punctuation.d.ts

@@ -0,0 +1,71 @@
+import { MathGateDiagnostic } from './gate-math.js';
+import { NotationLessonInput } from './types.js';
+
+/**
+ * The trailing-punctuation gate (rule N12): math never ends in the sentence's
+ * own `.`, `,`, `;` or `:`. It runs from the CLI alongside the completeness
+ * gate (`gate-math.ts`) over the same spans (`mathSpans`: every `$…$` /
+ * `$$…$$` in a lesson body, including table cells and component slots, and in
+ * an assessment item's `prompt` / `explanation`), and shares its
+ * `MathGateDiagnostic` shape and output array.
+ *
+ * "Ends" is read the way a reader sees it, not the raw source: trailing
+ * spacing (`\,`, `\quad`), `\label{…}` / `\caption{…}` / `\tag{…}`, a row break `\\`, an
+ * `\end{…}`, and the invisible delimiter `\right.` are looked through, and a
+ * closing `\text{…}` / `\mathrm{…}` is looked into — so `5\ \text{m,}` and
+ * `c &= d. \end{aligned}` are both caught. Every row of a multi-line block
+ * (the text before each `\\`) is checked the same way.
+ *
+ * Two shapes are called out by name because they look like notation: a
+ * trailing decimal point (`5.`) — a precision marker that cannot be told
+ * apart from the full stop, so it is never allowed — and a typed `...`
+ * (write `\ldots`). The one exception is a dotted abbreviation set upright
+ * that is itself notation (`+ \text{h.c.}`, `X_n \to X\ \text{a.s.}`): the
+ * shipped {@link MATH_END_ABBREVIATIONS}, edited per course with
+ * `rules.N12.allow` / `deny`.
+ */
+
+interface AssessmentItemLike {
+    readonly id?: string;
+    readonly prompt?: string;
+    readonly explanation?: string;
+}
+interface AssessmentLike {
+    readonly id: string;
+    readonly items?: readonly AssessmentItemLike[];
+}
+/** Dotted abbreviations that are notation, so they may end math (`\text{h.c.}`). */
+declare const MATH_END_ABBREVIATIONS: readonly string[];
+interface MathPunctuationOptions {
+    /** Abbreviations allowed in addition to {@link MATH_END_ABBREVIATIONS}. */
+    readonly allow?: readonly string[];
+    /** Shipped abbreviations this course does not accept. */
+    readonly deny?: readonly string[];
+}
+interface PunctuationFinding {
+    /** Index of the mark in the LaTeX. */
+    readonly index: number;
+    readonly mark: string;
+    readonly kind: 'sentence' | 'decimal' | 'ellipsis' | 'abbreviation';
+    /** True when the mark ends a row (text before a `\\`), not the whole span. */
+    readonly rowEnd: boolean;
+    /** The upright dotted word the mark closes (`etc.`), for `abbreviation`. */
+    readonly word?: string;
+}
+/** Every N12 finding in one span of LaTeX (the text between the `$` delimiters). */
+declare function trailingPunctuation(latex: string, options?: MathPunctuationOptions): PunctuationFinding[];
+/**
+ * Scan every lesson body's math for the sentence's own trailing punctuation.
+ * One error per mark, located at the mark itself, so a per-place waiver
+ * (`{/* explico-allow N12: reason *\/}`) can cover it.
+ */
+declare function gateMathPunctuation(lessons: readonly NotationLessonInput[], options?: MathPunctuationOptions): MathGateDiagnostic[];
+/**
+ * The same check over every assessment item's `prompt` / `explanation`, which
+ * render through the same KaTeX pipeline as lesson math. No line number: the
+ * item is one JSON string field, so `file` names the item, the same
+ * `"<assessmentId> (<itemId>)"` shape `gate-math.ts` uses.
+ */
+declare function gateMathPunctuationInAssessments(assessments: readonly AssessmentLike[], options?: MathPunctuationOptions): MathGateDiagnostic[];
+
+export { MATH_END_ABBREVIATIONS, type MathPunctuationOptions, type PunctuationFinding, gateMathPunctuation, gateMathPunctuationInAssessments, trailingPunctuation };

package/dist/reference/gate-math-punctuation.js

@@ -0,0 +1,251 @@
+import { equationLinkFor, mathSpans } from "./gate-math.js";
+import { lessonLine } from "./gate-prose-notation.js";
+const MATH_END_ABBREVIATIONS = [
+  "a.e.",
+  "a.s.",
+  "c.c.",
+  "const.",
+  "h.c.",
+  "i.i.d."
+];
+const LETTERS = /[A-Za-z]+/y;
+function tokenize(latex) {
+  const tokens = [];
+  const stack = [];
+  let i = 0;
+  while (i < latex.length) {
+    const ch = latex[i];
+    const parent = stack.length === 0 ? -1 : stack[stack.length - 1];
+    if (ch === "%") {
+      const newline = latex.indexOf("\n", i);
+      i = newline === -1 ? latex.length : newline;
+      continue;
+    }
+    if (ch === "\\") {
+      LETTERS.lastIndex = i + 1;
+      const letters = LETTERS.exec(latex);
+      const name = letters ? letters[0] : latex.charAt(i + 1);
+      tokens.push({ kind: "command", text: name, start: i, match: -1, parent });
+      i += 1 + Math.max(name.length, 1);
+      continue;
+    }
+    if (ch === "{") {
+      tokens.push({ kind: "open", text: ch, start: i, match: -1, parent });
+      stack.push(tokens.length - 1);
+    } else if (ch === "}") {
+      const open = stack.pop();
+      const index = tokens.length;
+      tokens.push({
+        kind: "close",
+        text: ch,
+        start: i,
+        match: open ?? -1,
+        parent: open === void 0 ? -1 : tokens[open].parent
+      });
+      if (open !== void 0) tokens[open].match = index;
+    } else {
+      tokens.push({ kind: /\s/.test(ch) ? "space" : "char", text: ch, start: i, match: -1, parent });
+    }
+    i += 1;
+  }
+  return tokens;
+}
+const MARKS = /* @__PURE__ */ new Set([".", ",", ";", ":"]);
+const INVISIBLE = /* @__PURE__ */ new Set([
+  ",",
+  ";",
+  ":",
+  "!",
+  " ",
+  "\\",
+  "quad",
+  "qquad",
+  "enspace",
+  "thinspace",
+  "medspace",
+  "thickspace",
+  "negthinspace",
+  "negmedspace",
+  "negthickspace",
+  "nonumber",
+  "notag",
+  "displaystyle",
+  "textstyle"
+]);
+const SKIPPED_GROUP = /* @__PURE__ */ new Set(["label", "caption", "tag", "begin", "end", "hspace", "vspace", "color"]);
+const UPRIGHT = /* @__PURE__ */ new Set(["text", "textrm", "textup", "textnormal", "mathrm", "mbox", "operatorname"]);
+const SIZER = /^(?:left|right|middle|[bB]igg?[lrm]?)$/;
+function groupOwner(tokens, open, from) {
+  let k = open - 1;
+  while (k >= from && tokens[k].kind === "space") k -= 1;
+  if (k >= from && tokens[k].kind === "char" && tokens[k].text === "*") k -= 1;
+  return k >= from && tokens[k].kind === "command" ? k : void 0;
+}
+function tail(tokens, from, to) {
+  let j = to - 1;
+  while (j >= from) {
+    const token = tokens[j];
+    if (token.kind === "space") {
+      j -= 1;
+      continue;
+    }
+    if (token.kind === "command" && INVISIBLE.has(token.text)) {
+      j -= 1;
+      continue;
+    }
+    if (token.kind === "char" && token.text === ".") {
+      const before = tokens[j - 1];
+      if (j - 1 >= from && before?.kind === "command" && SIZER.test(before.text)) {
+        j -= 2;
+        continue;
+      }
+    }
+    if (token.kind === "char" && token.text === "]") {
+      let open = j - 1;
+      while (open >= from && !(tokens[open].kind === "char" && tokens[open].text === "[")) open -= 1;
+      const breakToken = tokens[open - 1];
+      if (open - 1 >= from && breakToken?.kind === "command" && breakToken.text === "\\") {
+        j = open - 2;
+        continue;
+      }
+      return "clean";
+    }
+    if (token.kind === "close") {
+      if (token.match < from) return "clean";
+      const owner = groupOwner(tokens, token.match, from);
+      if (owner !== void 0 && SKIPPED_GROUP.has(tokens[owner].text)) {
+        j = owner - 1;
+        continue;
+      }
+      const inner = tail(tokens, token.match + 1, j);
+      if (inner !== "empty") return inner;
+      j = token.match - 1;
+      continue;
+    }
+    if (token.kind === "char" && MARKS.has(token.text)) return { mark: j };
+    return "clean";
+  }
+  return "empty";
+}
+function classify(tokens, j, rowEnd, allowed) {
+  const token = tokens[j];
+  const base = { index: token.start, mark: token.text, rowEnd };
+  if (token.text !== ".") return { ...base, kind: "sentence" };
+  const isChar = (k, pattern) => tokens[k]?.kind === "char" && pattern.test(tokens[k].text);
+  if (isChar(j - 1, /^\.$/)) return { ...base, kind: "ellipsis" };
+  if (isChar(j - 1, /^\d$/)) {
+    let k = j - 1;
+    while (isChar(k - 1, /^\d$/)) k -= 1;
+    if (!isChar(k - 1, /^[_^]$/)) return { ...base, kind: "decimal" };
+  }
+  const owner = token.parent >= 0 ? groupOwner(tokens, token.parent, 0) : void 0;
+  if (owner !== void 0 && UPRIGHT.has(tokens[owner].text)) {
+    let k = j;
+    while (isChar(k - 1, /^[A-Za-z.]$/)) k -= 1;
+    const word = tokens.slice(k, j + 1).map((t) => t.text).join("");
+    if (/[A-Za-z]/.test(word)) {
+      if (allowed.has(word)) return void 0;
+      return { ...base, kind: "abbreviation", word };
+    }
+  }
+  return { ...base, kind: "sentence" };
+}
+function allowedAbbreviations(options) {
+  const deny = new Set(options.deny ?? []);
+  return /* @__PURE__ */ new Set([
+    ...MATH_END_ABBREVIATIONS.filter((word) => !deny.has(word)),
+    ...options.allow ?? []
+  ]);
+}
+function findings(latex, allowed) {
+  const tokens = tokenize(latex);
+  const byMark = /* @__PURE__ */ new Map();
+  const record = (result, rowEnd) => {
+    if (typeof result !== "object" || byMark.has(result.mark)) return;
+    const finding = classify(tokens, result.mark, rowEnd, allowed);
+    if (finding) byMark.set(result.mark, finding);
+  };
+  tokens.forEach((token, k) => {
+    if (token.kind === "command" && token.text === "\\") record(tail(tokens, token.parent + 1, k), true);
+  });
+  record(tail(tokens, 0, tokens.length), false);
+  return [...byMark.values()].sort((left, right) => left.index - right.index);
+}
+function trailingPunctuation(latex, options = {}) {
+  return findings(latex, allowedAbbreviations(options));
+}
+const SEE = "See docs/authoring/notation.md#n12.";
+function messageFor(finding, snippet) {
+  const where = finding.rowEnd ? "ends a row of the math (before `\\\\`)" : "ends the math";
+  switch (finding.kind) {
+    case "decimal":
+      return `"${snippet}" ${where} with a trailing decimal point, which cannot be told apart from the sentence's full stop. Drop the point, or write the digits that state the precision (\`5.0\`); keep a full stop outside the math. ${SEE}`;
+    case "ellipsis":
+      return `"${snippet}" ${where} with a typed "...". Write \`\\ldots\`, and keep a full stop outside the math. ${SEE}`;
+    case "abbreviation":
+      return `"${snippet}" ${where} with "${finding.word}". If that abbreviation is notation (like \`\\text{h.c.}\`), add it to \`rules.N12.allow\`; if the "." is the sentence's full stop, move it after the closing \`$\`. ${SEE}`;
+    case "sentence":
+      return finding.rowEnd ? `"${snippet}" ${where} with "${finding.mark}" \u2014 the sentence's own punctuation. Drop it; the row break already separates the lines. ${SEE}` : `"${snippet}" ${where} with "${finding.mark}" \u2014 the sentence's own punctuation. Move it after the closing \`$\` (inline math) or drop it (display math). ${SEE}`;
+  }
+}
+function snippetOf(latex, index) {
+  const from = Math.max(0, index - 24);
+  const text = latex.slice(from, index + 1).replace(/\s+/g, " ").trimStart();
+  return from > 0 ? `\u2026${text}` : text;
+}
+function gateMathPunctuation(lessons, options = {}) {
+  const allowed = allowedAbbreviations(options);
+  const diagnostics = [];
+  for (const lesson of lessons) {
+    for (const span of mathSpans(lesson.body)) {
+      const equation = equationLinkFor(lesson.lessonId, span.latex);
+      for (const finding of findings(span.latex, allowed)) {
+        const at = span.offset + finding.index;
+        const snippet = snippetOf(span.latex, finding.index);
+        diagnostics.push({
+          context: "body",
+          code: "math-trailing-punctuation",
+          severity: "error",
+          file: lesson.source.file,
+          line: lessonLine(lesson, at),
+          column: at - lesson.body.lastIndexOf("\n", at - 1),
+          token: snippet,
+          ...equation === void 0 ? {} : { equation },
+          message: messageFor(finding, snippet)
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function gateMathPunctuationInAssessments(assessments, options = {}) {
+  const allowed = allowedAbbreviations(options);
+  const diagnostics = [];
+  for (const assessment of assessments) {
+    for (const item of assessment.items ?? []) {
+      for (const field of [item.prompt, item.explanation]) {
+        if (typeof field !== "string") continue;
+        for (const span of mathSpans(field)) {
+          for (const finding of findings(span.latex, allowed)) {
+            const snippet = snippetOf(span.latex, finding.index);
+            diagnostics.push({
+              context: "assessment",
+              code: "math-trailing-punctuation",
+              severity: "error",
+              file: `${assessment.id} (${item.id ?? "?"})`,
+              token: snippet,
+              message: messageFor(finding, snippet)
+            });
+          }
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+export {
+  MATH_END_ABBREVIATIONS,
+  gateMathPunctuation,
+  gateMathPunctuationInAssessments,
+  trailingPunctuation
+};