explico 0.11.1 → 0.13.0

package/src/reference/gate-indices.ts

@@ -0,0 +1,470 @@
+/**
+ * Rule N23 — an index is part of the symbol. A subscript on a symbol is
+ * explained by the indexed symbol's own entry (`v_0`), by a family entry
+ * whose index runs (`x_k` explains `x_1`), or by an index entry for the
+ * subscript (`{}_0`, which makes the derived card of `\mathbf{v}_0`); a card
+ * on the base alone does not explain it. Arithmetic on an index letter that
+ * has its own card is explained (`X_{t-1}`), and a subscript on an operator or
+ * a bracket is not an index (`\sum_{i=1}`). A running index — a lowercase
+ * letter the page does not declare fixed — states the set it runs over, on
+ * its card (`range`) or after a `\quad` on the first display line that uses
+ * it.
+ *
+ * The same pass collects the derived cards each page's body uses, which the
+ * manifest materializes (`derived-entries.ts`) whether or not the rule is on:
+ * the render path writes their keys either way.
+ *
+ * Lesson bodies, notation formulas and assessments are checked here; a lab's
+ * and a diagram's math, which only exists as they render, is checked there
+ * (`render-lab-math.ts`, `Diagram.astro`, through {@link indexFindings}). An
+ * indexed symbol takes a derived card wherever page math renders — a body,
+ * an assessment, a lab, a diagram — and never in a notation formula, which
+ * resolves against its own card's table. A span the resolver rejects is the
+ * completeness gate's to report. A body finding is located, so `explico-allow
+ * N23` waives it at one place.
+ */
+import { stripEquationLabels } from './equations.mjs';
+import { resolveMathGlyphs, stripNotationMarkers } from './math-glyphs.mjs';
+import {
+  equationLinkFor,
+  mathSpans,
+  pageScope,
+  suspendedOperators,
+  type AssessmentLike,
+  type LessonAssessmentLink,
+  type MathGateDiagnostic,
+  type ScopeEntry,
+} from './gate-math';
+import { formulaGlyphScope, type GlyphScopeEntry, type ResolvedGloss } from './gloss';
+import { indexOfEntry } from './math-glyphs.mjs';
+import type { DerivedUse, IndexedSymbol, NotationLessonInput } from './types';
+
+export type { DerivedUse } from './types';
+
+/** What the check needs of an entry besides its glyph-table row. */
+export interface IndexEntryFacts extends ScopeEntry {
+  readonly range?: string;
+  readonly formula?: string;
+  readonly glosses?: readonly ResolvedGloss[];
+  readonly source?: { readonly file: string };
+}
+
+/** Where a math source sits: what the message calls it, and its fix. */
+type Place = 'body' | 'formula' | 'assessment';
+
+/** How to explain an index where the source sits. */
+const INDEX_FIX: Record<Place, (token: string, subscript: string) => string> = {
+  body: (token, subscript) =>
+    `Give the indexed symbol its own entry (latex: ${token}), a family entry whose index ` +
+    `runs (latex: x_k), or an index entry for the subscript (latex: "{}_${subscript}", ` +
+    `label and meaning), introduced with [[key]] or in notation.local`,
+  assessment: (token, subscript) =>
+    `Give the indexed symbol its own entry (latex: ${token}), a family entry whose index ` +
+    `runs (latex: x_k), or an index entry for the subscript (latex: "{}_${subscript}"), ` +
+    `introduced in the lesson's prose with [[key]] or in its notation.local`,
+  formula: (token, subscript) =>
+    `In a formula, wrap the symbol in \\explain{key}{${token}} with an entry for the indexed ` +
+    `symbol, declare it under glosses: (latex: ${token}), or wrap the subscript in an index ` +
+    `entry's key (\\explain{key}{${subscript}})`,
+};
+
+interface Occurrence {
+  readonly letter: string;
+  readonly line: number;
+  readonly display: boolean;
+  /** The math line (between `\\` breaks) the letter is an index on. */
+  readonly mathLine: string;
+  readonly token: string;
+  readonly ownKey: string | null;
+  readonly coverKey: string | null;
+}
+
+const DISPLAY_OPEN = /\$\$\s*$/;
+const RANGE_RELATION =
+  /(?:=|<|>|\\(?:in|le|leq|ge|geq|lt|gt|dots|ldots|cdots|to|subseteq|subset)(?![A-Za-z]))/;
+
+/** The text after each `\quad` on a math line — never `\qquad` (rule N18's reason slot). */
+function quadClauses(mathLine: string): string[] {
+  return mathLine
+    .split(/\\quad(?![A-Za-z])/)
+    .slice(1)
+    .map((clause) => stripNotationMarkers(clause));
+}
+
+/** Whether a clause states the set `letter` runs over: `\quad i = 1, \dots, n`. */
+function statesRange(clause: string, letter: string): boolean {
+  const named = new RegExp(`(?<![A-Za-z\\\\])${letter}(?![A-Za-z])`);
+  return named.test(clause) && RANGE_RELATION.test(clause);
+}
+
+/** The `\\`-separated line of `latex` that holds `offset`. */
+function mathLineAt(latex: string, offset: number): string {
+  const before = latex.slice(0, offset).split(/\\\\/);
+  const after = latex.slice(offset).split(/\\\\/);
+  return `${before[before.length - 1] ?? ''}${after[0] ?? ''}`;
+}
+
+function message(
+  lessonId: string,
+  code: 'index-explained' | 'index-swallowed' | 'index-range' | 'derived-key-taken',
+  details: Record<string, string>,
+  place: Place = 'body',
+): string {
+  switch (code) {
+    case 'index-explained': {
+      const index = details.index ?? '';
+      const subscript = index.length === 1 ? index : `{${index}}`;
+      const what =
+        details.base === 'false'
+          ? `has no card, and neither does its base (${details.parts})`
+          : `has a subscript no card explains (${details.parts})`;
+      return (
+        `${lessonId}: ${JSON.stringify(details.token)} ${what}. ` +
+        `${INDEX_FIX[place](details.token ?? '', subscript)}; a letter in a subscript is an ` +
+        `index, so a base-library i, e or d there needs a card (rule N23).`
+      );
+    }
+    case 'index-swallowed':
+      return (
+        `${lessonId}: \\explain{${details.key}}{${details.token}} wraps an indexed symbol in ` +
+        `${details.key}, whose latex (${details.notation}) has no index, so its card cannot ` +
+        `explain ${JSON.stringify(details.index)}. Drop the wrap and give the subscript an index ` +
+        `entry (latex: "{}_${details.index}"), or wrap it in an entry for the indexed symbol (rule N23).`
+      );
+    case 'index-range':
+      return (
+        `${lessonId}: the running index ${details.letter} (first in ${JSON.stringify(details.token)}) ` +
+        `has no stated set. Give ${details.where} a range (range: "1, \\\\dots, n"), state it after a ` +
+        `\\quad on the first display line that uses it (\\quad ${details.letter} = 1, \\dots, n), or ` +
+        `mark the card fixedIndex: true if ${details.letter} is a label there, not a running index (rule N23).`
+      );
+    case 'derived-key-taken':
+      return (
+        `${lessonId}: ${JSON.stringify(details.token)} composes the derived card ${details.key}, ` +
+        `but an authored entry has that key. Rename the entry: a key of the form ` +
+        `<symbol>.sub.<index> is the build's (rule N23).`
+      );
+  }
+}
+
+/**
+ * Run rule N23 over every lesson (and non-chapter page) body, every notation
+ * formula and every assessment, and collect the derived cards each body
+ * uses. `entries` holds every shared entry by key; a lesson's own come from
+ * its `localDefinitions`. The index-set check (`index-range`) reads lesson
+ * bodies only: a letter's set is stated on its card or on the page.
+ */
+export function gateIndices(
+  lessons: readonly NotationLessonInput[],
+  entries: ReadonlyMap<string, IndexEntryFacts>,
+  extras: {
+    readonly assessments?: readonly AssessmentLike[];
+    readonly lessonAssessments?: readonly LessonAssessmentLink[];
+  } = {},
+): {
+  diagnostics: MathGateDiagnostic[];
+  derivedByLesson: Map<string, DerivedUse[]>;
+} {
+  const diagnostics: MathGateDiagnostic[] = [];
+  const derivedByLesson = new Map<string, DerivedUse[]>();
+
+  for (const lesson of lessons) {
+    const file = lesson.source.file;
+    const bodyOffset = (lesson.bodyLine ?? 1) - 1;
+    const scope = pageScope(lesson, entries);
+    const local = new Map<string, IndexEntryFacts>(
+      lesson.localDefinitions.map((definition) => [definition.key, definition]),
+    );
+    const factsOf = (key: string | null): IndexEntryFacts | undefined =>
+      key === null ? undefined : (local.get(key) ?? entries.get(key));
+    const suspended = suspendedOperators(lesson);
+    const derived = new Map<string, DerivedUse>();
+    const reported = new Set<string>();
+    const occurrences: Occurrence[] = [];
+
+    const spans = mathSpans(lesson.body).sort((left, right) => left.offset - right.offset);
+    for (const span of spans) {
+      const latex = stripEquationLabels(span.latex);
+      let result;
+      try {
+        result = resolveMathGlyphs(latex, scope, { suspended, derive: true });
+      } catch {
+        continue;
+      }
+      const line = span.line + bodyOffset;
+      const equation = equationLinkFor(lesson.lessonId, span.latex);
+      const at = {
+        context: 'body' as const,
+        severity: 'error' as const,
+        file,
+        line,
+        ...(equation === undefined ? {} : { equation }),
+      };
+      const display = DISPLAY_OPEN.test(lesson.body.slice(0, span.offset));
+
+      for (const use of result.derived) {
+        if (!derived.has(use.key)) derived.set(use.key, use);
+        if (factsOf(use.key) !== undefined && !reported.has(`taken:${use.key}`)) {
+          reported.add(`taken:${use.key}`);
+          diagnostics.push({
+            ...at,
+            code: 'derived-key-taken',
+            token: use.key,
+            message: message(lesson.lessonId, 'derived-key-taken', {
+              key: use.key,
+              token: use.key,
+            }),
+          });
+        }
+      }
+
+      for (const item of result.indices) {
+        pushFindings(item, at, lesson.lessonId, 'body', factsOf, reported, diagnostics);
+        for (const running of item.running) {
+          // A letter with no card at all is `index-explained`'s, or N4's.
+          if (running.key === null && running.cover === null) continue;
+          occurrences.push({
+            letter: running.letter,
+            line,
+            display,
+            mathLine: mathLineAt(latex, running.start),
+            token: item.token,
+            ownKey: running.key,
+            coverKey: running.cover,
+          });
+        }
+      }
+    }
+
+    // `index-range`: once per running letter per page.
+    const byLetter = new Map<string, Occurrence[]>();
+    for (const occurrence of occurrences) {
+      const list = byLetter.get(occurrence.letter) ?? [];
+      list.push(occurrence);
+      byLetter.set(occurrence.letter, list);
+    }
+    for (const [letter, list] of byLetter) {
+      const declared = list.some((occurrence) =>
+        [occurrence.ownKey, occurrence.coverKey].some((key) => {
+          const facts = factsOf(key);
+          return facts?.range !== undefined || facts?.fixedIndex === true;
+        }),
+      );
+      if (declared) continue;
+      const firstDisplay = list.find((occurrence) => occurrence.display);
+      if (
+        firstDisplay &&
+        quadClauses(firstDisplay.mathLine).some((clause) => statesRange(clause, letter))
+      ) {
+        continue;
+      }
+      const [first] = list;
+      if (!first) continue;
+      const card = first.ownKey ?? first.coverKey;
+      diagnostics.push({
+        context: 'body',
+        severity: 'error',
+        code: 'index-range',
+        file,
+        line: first.line,
+        token: letter,
+        message: message(lesson.lessonId, 'index-range', {
+          letter,
+          token: first.token,
+          where: card === null ? `the card of ${letter}` : `the card ${card}`,
+        }),
+      });
+    }
+
+    if (derived.size > 0) derivedByLesson.set(lesson.lessonId, [...derived.values()]);
+
+    // A notation.local formula, against the table the formula gate uses.
+    for (const definition of lesson.localDefinitions) {
+      if (!definition.formula || indexOfEntry(definition.notation) !== undefined) continue;
+      checkFormula(
+        definition.formula,
+        dedupeRows([...scope, ...definition.glosses]),
+        `${lesson.lessonId}: notation.local ${definition.key} formula`,
+        file,
+        factsOf,
+        reported,
+        diagnostics,
+      );
+    }
+  }
+
+  // A shared entry's formula, against its own table (D15). Each formula is
+  // its own place: a form two formulas leave unexplained is reported in both.
+  const cards = new Map<string, GlyphScopeEntry>(entries);
+  for (const entry of entries.values()) {
+    if (!entry.formula || indexOfEntry(entry.notation) !== undefined) continue;
+    checkFormula(
+      entry.formula,
+      formulaGlyphScope({
+        key: entry.key,
+        notation: entry.notation,
+        formula: entry.formula,
+        glosses: entry.glosses ?? [],
+        cardsByKey: cards,
+      }),
+      `notation ${entry.key} formula`,
+      entry.source?.file ?? `content/notation/${entry.key}.md`,
+      (key) => (key === null ? undefined : entries.get(key)),
+      new Set<string>(),
+      diagnostics,
+    );
+  }
+
+  // Assessment math renders on its lesson's page, with that page's table.
+  const lessonById = new Map(lessons.map((lesson) => [lesson.lessonId, lesson]));
+  const assessmentById = new Map(
+    (extras.assessments ?? []).map((assessment) => [assessment.id, assessment]),
+  );
+  for (const link of extras.lessonAssessments ?? []) {
+    const lesson = lessonById.get(link.lessonId);
+    if (!lesson) continue;
+    const scope = pageScope(lesson, entries);
+    const local = new Map<string, IndexEntryFacts>(
+      lesson.localDefinitions.map((definition) => [definition.key, definition]),
+    );
+    const factsOf = (key: string | null): IndexEntryFacts | undefined =>
+      key === null ? undefined : (local.get(key) ?? entries.get(key));
+    for (const assessmentId of link.assessmentIds) {
+      const assessment = assessmentById.get(assessmentId);
+      const reported = new Set<string>();
+      for (const item of assessment?.items ?? []) {
+        for (const field of [
+          item.prompt,
+          item.explanation,
+          ...(item.options ?? []).map((option) => option.label),
+        ]) {
+          if (typeof field !== 'string') continue;
+          for (const span of mathSpans(field)) {
+            let result;
+            try {
+              result = resolveMathGlyphs(span.latex, scope, { derive: true });
+            } catch {
+              continue;
+            }
+            const at = {
+              context: 'assessment' as const,
+              severity: 'error' as const,
+              file: `${assessmentId} (${item.id ?? '?'})`,
+              line: span.line,
+            };
+            for (const indexed of result.indices) {
+              pushFindings(
+                indexed,
+                at,
+                `${link.lessonId}: assessment ${assessmentId}`,
+                'assessment',
+                factsOf,
+                reported,
+                diagnostics,
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { diagnostics, derivedByLesson };
+}
+
+/** `index-explained` or `index-swallowed` for one indexed symbol, once per form. */
+function pushFindings(
+  item: IndexedSymbol,
+  at: Omit<MathGateDiagnostic, 'code' | 'message'>,
+  owner: string,
+  place: Place,
+  factsOf: (key: string | null) => IndexEntryFacts | undefined,
+  reported: Set<string>,
+  diagnostics: MathGateDiagnostic[],
+): void {
+  const token = item.token.replace(/\s+/g, '');
+  if (item.how === 'swallowed' && !reported.has(`swallowed:${token}`)) {
+    reported.add(`swallowed:${token}`);
+    diagnostics.push({
+      ...at,
+      code: 'index-swallowed',
+      token: item.token,
+      message: message(owner, 'index-swallowed', {
+        key: item.key ?? '',
+        token: item.token,
+        notation: factsOf(item.key)?.notation ?? '',
+        index: item.index,
+      }),
+    });
+  } else if (item.how === 'composed' && !item.explained && !reported.has(`explained:${token}`)) {
+    reported.add(`explained:${token}`);
+    diagnostics.push({
+      ...at,
+      code: 'index-explained',
+      token: item.token,
+      message: message(
+        owner,
+        'index-explained',
+        {
+          token: item.token,
+          index: item.index.replace(/^\{([\s\S]*)\}$/, '$1'),
+          parts: item.unexplained.map((part) => JSON.stringify(part)).join(', '),
+          base: String(item.baseExplained),
+        },
+        place,
+      ),
+    });
+  }
+}
+
+/** Rule N23 in one notation formula: derived cards do not compose there. */
+function checkFormula(
+  formula: string,
+  scope: readonly ScopeEntry[],
+  owner: string,
+  file: string,
+  factsOf: (key: string | null) => IndexEntryFacts | undefined,
+  reported: Set<string>,
+  diagnostics: MathGateDiagnostic[],
+): void {
+  let result;
+  try {
+    result = resolveMathGlyphs(formula, [...scope]);
+  } catch {
+    return;
+  }
+  const at = { context: 'formula' as const, severity: 'error' as const, file };
+  for (const item of result.indices) {
+    pushFindings(item, at, owner, 'formula', factsOf, reported, diagnostics);
+  }
+}
+
+/** A glyph table with each key once, the first row winning. */
+function dedupeRows(rows: readonly ScopeEntry[]): ScopeEntry[] {
+  const seen = new Set<string>();
+  return rows.filter((row) => !seen.has(row.key) && Boolean(seen.add(row.key)));
+}
+
+/**
+ * Rule N23's findings in one math source rendered outside a lesson body — a
+ * lab's or a diagram's, which fail the build as they render — as one line
+ * each: the form, what explains none of it, and the fix.
+ */
+export function indexFindings(indices: readonly IndexedSymbol[]): string[] {
+  return indices.flatMap((item) => {
+    if (item.how === 'swallowed') {
+      return [
+        `${item.token}: \\explain{${item.key ?? ''}}{…} names an entry whose latex has no ` +
+          `index, so its card cannot explain ${JSON.stringify(item.index)}; give the subscript an ` +
+          `index entry ({}_${item.index.length === 1 ? item.index : `{${item.index}}`}) and drop the wrap, or name an entry for the indexed symbol`,
+      ];
+    }
+    if (item.how !== 'composed' || item.explained) return [];
+    return [
+      `${item.token}: no card explains ${item.unexplained
+        .map((part) => JSON.stringify(part))
+        .join(', ')}; give the indexed symbol its own entry, a family entry (x_k), or an ` +
+        `index entry for the subscript ({}_0) in the page's notation`,
+    ];
+  });
+}

package/src/reference/gate-math.ts

@@ -24,6 +24,7 @@ import type {
   NotationRegistryInput,
   SharedNotationDefinitionInput,
 } from './types';
+import { blankPropStrings } from './gate-prop-text';
 
 /**
  * The equation a finding sits in, when its math carries a `\label{eq:…}`.
@@ -99,16 +100,18 @@ const SEVERITY: Record<MathGateDiagnostic['context'], 'error' | 'warning'> = {
   course: 'error',
 };
 
-interface AssessmentItemLike {
+export interface AssessmentItemLike {
   readonly id?: string;
   readonly prompt?: string;
   readonly explanation?: string;
+  /** A choice item's options; a label's math renders like the prompt's. */
+  readonly options?: readonly { readonly label?: string }[];
 }
-interface AssessmentLike {
+export interface AssessmentLike {
   readonly id: string;
   readonly items?: readonly AssessmentItemLike[];
 }
-interface LessonAssessmentLink {
+export interface LessonAssessmentLink {
   readonly lessonId: string;
   readonly assessmentIds: readonly string[];
 }
@@ -136,9 +139,13 @@ export interface MathSpan {
   readonly offset: number;
 }
 
-/** Every `$$…$$` then `$…$` span in `body`, outside code, with its position. */
+/**
+ * Every `$$…$$` then `$…$` span in `body`, outside code and quoted JSX props
+ * (plain text that never reaches KaTeX; invariant `prop-text`), with its
+ * position.
+ */
 export function mathSpans(body: string): MathSpan[] {
-  const searchable = stripCode(body);
+  const searchable = stripCode(blankPropStrings(body));
   const spans: MathSpan[] = [];
   for (const pattern of [DISPLAY_MATH, INLINE_MATH]) {
     pattern.lastIndex = 0;
@@ -159,7 +166,24 @@ export function mathSpans(body: string): MathSpan[] {
   return spans;
 }
 
-export type ScopeEntry = { key: string; notation: string };
+/**
+ * One row of a page's glyph table. `fixedIndex` (rule N23) tells the
+ * resolver that an entry's index is a fixed label, so it is no family.
+ */
+export type ScopeEntry = { key: string; notation: string; fixedIndex?: true };
+
+/** A definition as a glyph-table row, `fixedIndex` kept. */
+export function scopeEntry(definition: {
+  readonly key: string;
+  readonly notation: string;
+  readonly fixedIndex?: true;
+}): ScopeEntry {
+  return {
+    key: definition.key,
+    notation: definition.notation,
+    ...(definition.fixedIndex ? { fixedIndex: true as const } : {}),
+  };
+}
 
 /**
  * A lesson's flat glyph table: its own `notation.local` entries plus every
@@ -172,10 +196,7 @@ export function pageScope(
   lesson: NotationLessonInput,
   sharedByKey: ReadonlyMap<string, ScopeEntry>,
 ): ScopeEntry[] {
-  const local = lesson.localDefinitions.map((definition) => ({
-    key: definition.key,
-    notation: definition.notation,
-  }));
+  const local = lesson.localDefinitions.map(scopeEntry);
   const localKeys = new Set(local.map((entry) => entry.key));
 
   const referenced = new Set<string>();
@@ -187,7 +208,7 @@ export function pageScope(
   for (const key of referenced) {
     if (localKeys.has(key)) continue;
     const shared = sharedByKey.get(key);
-    if (shared) scope.push({ key: shared.key, notation: shared.notation });
+    if (shared) scope.push(scopeEntry(shared));
   }
   return scope;
 }
@@ -227,6 +248,7 @@ function resolveInto(
   out: MathGateDiagnostic[],
   equation?: EquationLink,
   suspended: readonly string[] = [],
+  derive = false,
 ): void {
   const at = equation === undefined ? {} : { equation };
   for (const diagnostic of lintDelimiterSizes(latex)) {
@@ -255,6 +277,7 @@ function resolveInto(
     // D7: `\label{eq:…}` is an identity marker, not math KaTeX parses.
     result = resolveMathGlyphs(stripEquationLabels(latex), [...scope], {
       suspended,
+      derive,
     });
   } catch (error) {
     out.push({
@@ -297,6 +320,11 @@ function resolveInto(
       'font' in item && typeof item.font === 'string'
         ? ` ${token} is a different symbol from the plain letter: give it its own entry (latex: ${token}) or wrap it in \\explain{key}{${token}}.`
         : '';
+    // Rule N23: an indexed entry with this base explains no bare letter.
+    const lenderHint =
+      'lenders' in item && Array.isArray(item.lenders) && item.lenders.length > 0
+        ? ` ${item.lenders.join(', ')} ${item.lenders.length === 1 ? 'has' : 'have'} ${token} with a subscript, and an indexed entry explains its own instances only, never a bare ${token} (rule N4). If ${token} is a different object, give it its own entry (latex: ${token}); if it is shorthand for that entry, wrap it in \\explain{${item.lenders[0]}}{${token}}.`
+        : '';
     out.push({
       context,
       code: 'unresolved-glyph',
@@ -305,11 +333,45 @@ function resolveInto(
       line,
       token,
       ...at,
-      message: `Unresolved notation ${JSON.stringify(token)} in ${context} math.${fontHint} ${fix}`,
+      message: `Unresolved notation ${JSON.stringify(token)} in ${context} math.${fontHint}${lenderHint} ${fix}`,
     });
   }
 }
 
+/**
+ * The `$…$` pairs remark-math reads as math that hold an amount of money
+ * instead: `$5 to $6`, `$5–$10`, `$5, and $x`. remark-math pairs any two
+ * single `$` on a line, left to right; `mathSpans` follows Pandoc (no space
+ * before a closing `$`, no digit after it) and skips them, so such a pair was
+ * neither checked as math nor shown as money — the page printed "5 to 6", or
+ * the build failed on the letters of "and". A pair is money when its content
+ * starts with a digit and either ends in a space or runs straight into a
+ * digit after the closing `$`.
+ */
+export function currencyDollars(body: string): MathSpan[] {
+  const searchable = stripCode(blankPropStrings(body)).replace(DISPLAY_MATH, (block) =>
+    block.replace(/[^\n]/g, ' '),
+  );
+  const spans: MathSpan[] = [];
+  let lineStart = 0;
+  searchable.split('\n').forEach((text, index) => {
+    const dollars: number[] = [];
+    for (let at = 0; at < text.length; at += 1) {
+      if (text[at] !== '$' || text[at - 1] === '\\' || text[at - 1] === '$' || text[at + 1] === '$') continue;
+      dollars.push(at);
+    }
+    for (let pair = 0; pair + 1 < dollars.length; pair += 2) {
+      const open = dollars[pair]!;
+      const close = dollars[pair + 1]!;
+      const latex = text.slice(open + 1, close);
+      if (!/^\d/.test(latex) || !(/\s$/.test(latex) || /^\d/.test(text.slice(close + 1)))) continue;
+      spans.push({ latex, line: index + 1, column: open + 2, offset: lineStart + open + 1 });
+    }
+    lineStart += text.length + 1;
+  });
+  return spans;
+}
+
 const BODY_FIX =
   'Introduce the symbol with [[key]], define it in notation.local, or wrap it in \\explain{key}{latex}.';
 function dedupeScope(scope: readonly GlyphScopeEntry[]): GlyphScopeEntry[] {
@@ -424,9 +486,28 @@ export function gateContentMath(input: {
         diagnostics,
         equationLinkFor(lesson.lessonId, span.latex),
         suspended,
+        // Derived cards (rule N23) are lesson-body math, like the render path.
+        true,
       );
     }
 
+    for (const span of currencyDollars(lesson.body)) {
+      const shown = span.latex.replace(/\s+$/, '');
+      diagnostics.push({
+        context: 'body',
+        code: 'currency-dollar',
+        severity: SEVERITY.body,
+        file,
+        line: span.line + bodyOffset,
+        column: span.column,
+        token: `$${span.latex}$`,
+        message:
+          `"$${span.latex}$" reads as math: remark-math pairs any two dollars on a line, so the ` +
+          `page shows "${shown}" without them. Write a currency dollar as \\$ (\\$5 to \\$6), ` +
+          'or the amount in words.',
+      });
+    }
+
     for (const definition of lesson.localDefinitions) {
       if (!definition.formula) continue;
       // `scope` already carries every page-local entry, including this one, so
@@ -491,7 +572,11 @@ export function gateContentMath(input: {
       const assessment = assessmentById.get(assessmentId);
       if (!assessment?.items) continue;
       for (const item of assessment.items) {
-        for (const field of [item.prompt, item.explanation]) {
+        for (const field of [
+          item.prompt,
+          item.explanation,
+          ...(item.options ?? []).map((option) => option.label),
+        ]) {
           if (typeof field !== 'string') continue;
           for (const span of mathSpans(field)) {
             resolveInto(
@@ -503,6 +588,10 @@ export function gateContentMath(input: {
               span.column,
               ASSESSMENT_FIX,
               diagnostics,
+              undefined,
+              [],
+              // Page math, rendered with derived cards (rule N23).
+              true,
             );
           }
         }