explico 0.12.0 → 0.13.0

package/dist/curriculum/validation.d.ts

@@ -10,7 +10,6 @@ interface CompetencyDefinition {
 }
 interface LessonDefinition {
     readonly id: string;
-    readonly status: 'draft' | 'in-review' | 'reviewed';
     readonly requires: readonly string[];
     readonly teaches: readonly string[];
     readonly assessments: readonly string[];
@@ -23,6 +22,8 @@ interface AssessmentItemBase {
     readonly id: string;
     readonly competencyId: string;
     readonly evidenceKind: 'direct' | 'transfer';
+    readonly prompt?: string;
+    readonly explanation?: string;
 }
 interface NumericAssessmentItem extends AssessmentItemBase {
     readonly type: 'numeric';
@@ -45,7 +46,6 @@ interface AssessmentDefinition {
 }
 interface SourceDefinition {
     readonly id: string;
-    readonly editorialStatus: 'draft' | 'in-review' | 'reviewed';
 }
 interface TrackDefinition {
     readonly id: string;
@@ -59,8 +59,14 @@ interface CurriculumCatalog {
     readonly tracks: readonly TrackDefinition[];
 }
 interface CurriculumIssue {
-    readonly kind: 'invalid-id' | 'duplicate-id' | 'unknown-reference' | 'duplicate-reference' | 'self-prerequisite' | 'cycle' | 'lesson-order' | 'track-order' | 'assessment-coverage' | 'invalid-assessment' | 'review-state' | 'teaches-support';
+    readonly kind: 'invalid-id' | 'duplicate-id' | 'unknown-reference' | 'duplicate-reference' | 'self-prerequisite' | 'cycle' | 'lesson-order' | 'track-order' | 'assessment-coverage' | 'invalid-assessment' | 'missing-assumptions' | 'teaches-support' | 'retired-key' | 'content-schema' | 'part-empty' | 'lesson-outside-parts' | 'unsupported-key' | 'ignored-key' | 'markup-in-prop' | 'citation-in-link';
     readonly message: string;
+    /**
+     * The content file the issue is about, when it is about one file rather
+     * than the graph (`retired-key`, `content-schema`), and the 1-based line in it.
+     */
+    readonly file?: string;
+    readonly line?: number;
     /**
      * `error` (default) blocks the build; `warning` is reported but non-blocking.
      * New checks enter as warnings and are promoted once they run clean on real

package/dist/curriculum/validation.js

@@ -1,3 +1,5 @@
+import { citationsInLinks, citedIds, withoutLinkCitations } from "../reference/citation-format.mjs";
+const CHECK_TEXT_REFERENCE = /\[\[[^\]\n]*\]\]|\[@[^\]\n]*\]/;
 const VALID_ID = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
 function buildIndex(kind, entries, issues) {
   const index = /* @__PURE__ */ new Map();
@@ -23,13 +25,7 @@ function buildIndex(kind, entries, issues) {
 function citedSourceIds(body) {
   if (!body) return /* @__PURE__ */ new Set();
   const withoutCode = body.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]*`/g, "");
-  const ids = /* @__PURE__ */ new Set();
-  for (const match of withoutCode.matchAll(
-    /\[@([a-z0-9][a-z0-9.-]*)(?:;[^\]]*)?\]/g
-  )) {
-    ids.add((match[1] ?? "").trim());
-  }
-  return ids;
+  return citedIds(withoutLinkCitations(withoutCode));
 }
 function findDuplicates(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -173,18 +169,22 @@ function validateCurriculum(catalog) {
       }
     }
     const cited = citedSourceIds(lesson.body);
+    if (lesson.body !== void 0) {
+      const blank = (code) => code.replace(/[^\n]/g, " ");
+      const prose = lesson.body.replace(/```[\s\S]*?```/g, blank).replace(/`[^`\n]*`/g, blank);
+      for (const { text } of citationsInLinks(prose)) {
+        issues.push({
+          kind: "citation-in-link",
+          message: `${lesson.id} puts the citation ${text} inside a link's text, where it prints as typed: a link cannot hold the citation's own link. Cite after the link: [the words](https://\u2026) ${text}.`
+        });
+      }
+    }
     for (const sourceId of lesson.sources) {
-      const source = sources.get(sourceId);
-      if (!source) {
+      if (!sources.has(sourceId)) {
         issues.push({
           kind: "unknown-reference",
           message: `${lesson.id} references unknown source ${sourceId}`
         });
-      } else if (lesson.status === "reviewed" && source.editorialStatus !== "reviewed") {
-        issues.push({
-          kind: "review-state",
-          message: `${lesson.id} is reviewed but source ${sourceId} is ${source.editorialStatus}`
-        });
       }
       if (lesson.body !== void 0 && !cited.has(sourceId)) {
         issues.push({
@@ -203,7 +203,7 @@ function validateCurriculum(catalog) {
     }
     if (lesson.teaches.length > 0 && lesson.assumptions.length === 0) {
       issues.push({
-        kind: "review-state",
+        kind: "missing-assumptions",
         message: `${lesson.id} teaches quantitative content but declares no assumptions`
       });
     }
@@ -232,10 +232,28 @@ function validateCurriculum(catalog) {
             message: `${assessment.id}/${item.id} has unknown correct option ${item.correctOptionId}`
           });
         }
-      } else if (!Number.isFinite(item.answer.value) || !Number.isFinite(item.answer.tolerance) || item.answer.tolerance <= 0) {
+      } else if (!Number.isFinite(item.answer.value)) {
+        issues.push({
+          kind: "invalid-assessment",
+          message: `${assessment.id}/${item.id} answer.value must be a number`
+        });
+      } else if (!Number.isFinite(item.answer.tolerance) || item.answer.tolerance <= 0) {
+        issues.push({
+          kind: "invalid-assessment",
+          message: `${assessment.id}/${item.id} answer.tolerance must be a number greater than 0, not ${String(item.answer.tolerance)}: an answer within it of answer.value is correct. For an exact whole-number answer, use a tolerance below one half, such as 0.4.`
+        });
+      }
+      const texts = [
+        ["prompt", item.prompt],
+        ["explanation", item.explanation],
+        ...item.type === "single-choice" ? item.options.map((option) => [`option ${option.id}`, option.label]) : []
+      ];
+      for (const [field, text] of texts) {
+        const found = text === void 0 ? null : CHECK_TEXT_REFERENCE.exec(text);
+        if (!found) continue;
         issues.push({
           kind: "invalid-assessment",
-          message: `${assessment.id}/${item.id} has an invalid numeric answer or tolerance`
+          message: `${assessment.id}/${item.id} ${field} contains ${found[0]}, which a knowledge check shows exactly as written: its text renders math, not references or citations. Name the equation, section or source in words, or cite it in the lesson text the check follows.`
         });
       }
       const evidence = evidenceByCompetency.get(item.competencyId) ?? {

package/dist/reference/base-abbreviations.d.mts

@@ -24,7 +24,7 @@ export function isBaseAbbreviation(token: any, abbreviations: any): boolean;
  * `content/abbreviations/*.md` table, not here. This baseline only holds
  * abbreviations so common in ordinary English/academic writing that spelling
  * them out on every course would be noise, not help. A course adds a real
- * one via `abbreviations.allow` in `course.config.ts`, the same shape as
- * `operators.allow` / `romanLabels.allow`.
+ * one via `rules.N14.allow` in its course config, the same shape as
+ * `rules.N8.allow` / `rules.N10.allow`.
  */
 export const BASE_ABBREVIATIONS: Readonly<Set<string>>;

package/dist/reference/base-abbreviations.mjs

@@ -11,8 +11,8 @@
  * `content/abbreviations/*.md` table, not here. This baseline only holds
  * abbreviations so common in ordinary English/academic writing that spelling
  * them out on every course would be noise, not help. A course adds a real
- * one via `abbreviations.allow` in `course.config.ts`, the same shape as
- * `operators.allow` / `romanLabels.allow`.
+ * one via `rules.N14.allow` in its course config, the same shape as
+ * `rules.N8.allow` / `rules.N10.allow`.
  */
 export const BASE_ABBREVIATIONS = Object.freeze(
   new Set([

package/dist/reference/base-operators.d.mts

@@ -34,8 +34,8 @@ export function isBaseOperator(name: any, operators: any): boolean;
  *
  * A domain operator (`Var`, `Cov`, `Corr`, `sgn`, `erf`, `Tr`, `argmax`, …) is
  * written `\operatorname{…}` and is NOT here: it earns a card, a
- * `notation.local` entry, or an explicit line in `course.config.ts`
- * (`operators.allow`).
+ * `notation.local` entry, or an explicit line in the course config
+ * (`rules.N8.allow`).
  *
  * Entries are the KaTeX command without its backslash (`exp`, not `\exp`) for
  * `op` nodes, and the verbatim body for `\operatorname{…}` nodes (`Var`).

package/dist/reference/base-operators.mjs

@@ -21,8 +21,8 @@
  *
  * A domain operator (`Var`, `Cov`, `Corr`, `sgn`, `erf`, `Tr`, `argmax`, …) is
  * written `\operatorname{…}` and is NOT here: it earns a card, a
- * `notation.local` entry, or an explicit line in `course.config.ts`
- * (`operators.allow`).
+ * `notation.local` entry, or an explicit line in the course config
+ * (`rules.N8.allow`).
  *
  * Entries are the KaTeX command without its backslash (`exp`, not `\exp`) for
  * `op` nodes, and the verbatim body for `\operatorname{…}` nodes (`Var`).

package/dist/reference/base-roman-labels.d.mts

@@ -28,8 +28,9 @@ export function isBaseRomanLabel(name: any, romanLabels: any): boolean;
  * always a course-specific named quantity (`KE`, `PV`, `Var`-as-a-label) that
  * genuinely benefits from a hover card, so the shipped baseline holds only
  * the qualifiers that function like an operator's extremum subscript
- * (`x_{\mathrm{opt}}`) rather than naming a quantity of their own. A course
- * adds a real one via `romanLabels.allow` in `course.config.ts`, the same
- * shape as `operators.allow`.
+ * (`x_{\mathrm{opt}}`) rather than naming a quantity of their own. That
+ * clears rule N10 only: the indexed symbol still needs a card (rule N23).
+ * A course adds a real one via `rules.N10.allow` in its course config, the
+ * same shape as `rules.N8.allow`.
  */
 export const BASE_ROMAN_LABELS: Readonly<Set<string>>;

package/dist/reference/base-roman-labels.mjs

@@ -15,9 +15,10 @@
  * always a course-specific named quantity (`KE`, `PV`, `Var`-as-a-label) that
  * genuinely benefits from a hover card, so the shipped baseline holds only
  * the qualifiers that function like an operator's extremum subscript
- * (`x_{\mathrm{opt}}`) rather than naming a quantity of their own. A course
- * adds a real one via `romanLabels.allow` in `course.config.ts`, the same
- * shape as `operators.allow`.
+ * (`x_{\mathrm{opt}}`) rather than naming a quantity of their own. That
+ * clears rule N10 only: the indexed symbol still needs a card (rule N23).
+ * A course adds a real one via `rules.N10.allow` in its course config, the
+ * same shape as `rules.N8.allow`.
  */
 export const BASE_ROMAN_LABELS = Object.freeze(new Set(['opt']));
 

package/dist/reference/citation-format.d.mts

@@ -44,6 +44,35 @@ export function referenceLabelFromText(referenceText: string, locator: string |
  * @returns {string}
  */
 export function formatSourceLabel(record: Record<string, unknown>): string;
+/**
+ * The citations one bracket holds, in order, as `{ id, locator }`. A
+ * `;`-separated part that is only `@id` starts another citation (Pandoc's
+ * `[@a; @b]`); any other part belongs to the locator of the citation before
+ * it, so a locator may itself contain `;` (`[@a; §1.2; eq. 3]`).
+ *
+ * @param {string} firstId
+ * @param {string | undefined} rest
+ * @returns {{ id: string, locator: string }[]}
+ */
+export function bracketCitations(firstId: string, rest: string | undefined): {
+    id: string;
+    locator: string;
+}[];
+/** Every source id a text cites, `[@a; @b]` included. */
+export function citedIds(text: any): Set<any>;
+/**
+ * Each citation written inside a link's text, as `{ index, text }`: the
+ * offset of its `[@` in `text`, and the citation as written.
+ */
+export function citationsInLinks(text: any): {
+    index: number;
+    text: string;
+}[];
+/**
+ * `text` with every citation inside a link's text blanked, offsets kept: what
+ * the page cites, for a scan that counts a lesson's sources.
+ */
+export function withoutLinkCitations(text: any): string;
 /**
  * Pure helpers for turning a source record plus a per-citation locator into
  * the strings shown in the inline panel and the end-of-page reference list.
@@ -53,3 +82,9 @@ export function formatSourceLabel(record: Record<string, unknown>): string;
  * file system, or Astro APIs.
  */
 export const SOURCE_ID_PATTERN: RegExp;
+/**
+ * One `[@…]` bracket: `[@id]`, `[@id; locator]`, or several citations as
+ * Pandoc writes them, `[@a; @b; p. 7]`. Group 1 is the first id, group 2 the
+ * rest after the first `;`, read by {@link bracketCitations}.
+ */
+export const CITATION_BRACKET: RegExp;

package/dist/reference/citation-format.mjs

@@ -131,3 +131,77 @@ export function formatSourceLabel(record) {
     .filter(Boolean)
     .join(', ');
 }
+
+/**
+ * One `[@…]` bracket: `[@id]`, `[@id; locator]`, or several citations as
+ * Pandoc writes them, `[@a; @b; p. 7]`. Group 1 is the first id, group 2 the
+ * rest after the first `;`, read by {@link bracketCitations}.
+ */
+export const CITATION_BRACKET = /\[@([a-z0-9][a-z0-9.-]*)(?:;[ \t\r\n]*([^\]]*))?\]/g;
+
+/**
+ * The citations one bracket holds, in order, as `{ id, locator }`. A
+ * `;`-separated part that is only `@id` starts another citation (Pandoc's
+ * `[@a; @b]`); any other part belongs to the locator of the citation before
+ * it, so a locator may itself contain `;` (`[@a; §1.2; eq. 3]`).
+ *
+ * @param {string} firstId
+ * @param {string | undefined} rest
+ * @returns {{ id: string, locator: string }[]}
+ */
+export function bracketCitations(firstId, rest) {
+  const citations = [{ id: String(firstId).trim(), parts: [] }];
+  for (const part of String(rest ?? '').split(';')) {
+    const next = /^\s*@([a-z0-9][a-z0-9.-]*)\s*$/.exec(part);
+    if (next) citations.push({ id: next[1], parts: [] });
+    else if (part.trim()) citations[citations.length - 1].parts.push(part);
+  }
+  return citations.map(({ id, parts }) => ({
+    id,
+    locator: parts.join(';').replace(/\s+/g, ' ').trim(),
+  }));
+}
+
+/** Every source id a text cites, `[@a; @b]` included. */
+export function citedIds(text) {
+  const ids = new Set();
+  for (const match of String(text).matchAll(CITATION_BRACKET)) {
+    for (const { id } of bracketCitations(match[1] ?? '', match[2])) ids.add(id);
+  }
+  return ids;
+}
+
+/**
+ * A Markdown link whose text holds a citation, `[as measured in [@id]](url)`:
+ * remark-citation leaves link text alone (a link cannot hold the marker's
+ * link), so the citation would print as typed. Group 1 is the link text.
+ */
+const LINK_WITH_CITATION = /\[((?:[^[\]\n]|\[[^[\]\n]*\])*?\[@[^\]\n]*\](?:[^[\]\n]|\[[^[\]\n]*\])*)\]\(/g;
+
+/**
+ * Each citation written inside a link's text, as `{ index, text }`: the
+ * offset of its `[@` in `text`, and the citation as written.
+ */
+export function citationsInLinks(text) {
+  const found = [];
+  for (const link of String(text).matchAll(LINK_WITH_CITATION)) {
+    const start = (link.index ?? 0) + 1;
+    for (const citation of (link[1] ?? '').matchAll(/\[@[^\]\n]*\]/g)) {
+      found.push({ index: start + (citation.index ?? 0), text: citation[0] });
+    }
+  }
+  return found;
+}
+
+/**
+ * `text` with every citation inside a link's text blanked, offsets kept: what
+ * the page cites, for a scan that counts a lesson's sources.
+ */
+export function withoutLinkCitations(text) {
+  let out = String(text);
+  for (const { index, text: citation } of citationsInLinks(out)) {
+    out = out.slice(0, index) + citation.replace(/[^\n]/g, ' ') + out.slice(index + citation.length);
+  }
+  return out;
+}
+

package/dist/reference/consistency.d.ts

@@ -1,10 +1,11 @@
-import { f as CourseConventions, g as CourseOperators, h as CourseRomanLabels, i as CourseAccents } from '../course-config-Dsnri9Tk.js';
-import { CurriculumCatalog } from '../curriculum/validation.js';
+import { e as CourseOperators, f as CourseRomanLabels, g as CourseAccents } from '../course-config-rRtME5UV.js';
 import { NotationSpec } from '../compiler/collections.js';
 import { LintIgnore } from './lint-ignore.js';
 import { NotationRegistry, NotationRegistryInput } from './types.js';
 import '../rules/catalog.js';
 import '../rules/course-rules.js';
+import '../curriculum/validation.js';
+import './gate-retired-keys.js';
 
 /**
  * Corpus consistency checks (Step D6) — the Tier 1–2 checks from the cleanup
@@ -20,9 +21,7 @@ import '../rules/course-rules.js';
  *   (a) glyph-unique-in-corpus       one rendered glyph → one meaning corpus-wide
  *   (b) notation-units / units-vocab  every entry has units or `dimensionless`,
  *                                     unit strings drawn from a controlled vocab
- *   (c) convention-single-definition  a sign / cash-flow-perspective convention a
- *                                     lesson uses resolves to one declaration
- *   (f) weak-local                   a `notation.local` symbol used only in its
+ *   (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
  *   (h) operator-explained           a named operator a lesson uses is on the
@@ -45,7 +44,7 @@ import '../rules/course-rules.js';
  * `src/content/resolution-report.ts`.
  */
 
-type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'convention-single-definition' | 'weak-local' | 'notation-source-locator' | 'gloss-wants-promoting' | 'card-wants-demoting' | 'gloss-name-shape' | 'operator-explained' | 'roman-label-explained' | 'accent-explained' | 'operator-suspended' | 'operator-suspension-reason' | 'operator-shadowed';
+type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'weak-local' | 'notation-source-locator' | 'gloss-wants-promoting' | 'card-wants-demoting' | 'gloss-name-shape' | 'operator-explained' | 'roman-label-explained' | 'accent-explained' | 'accent-swallowed' | 'operator-suspended' | 'operator-suspension-reason' | 'operator-shadowed';
 interface ConsistencyDiagnostic {
     readonly code: ConsistencyCode;
     /** Tier 3 — repairable violations are warnings; optional advice is info. */
@@ -62,10 +61,7 @@ interface ConsistencyInput {
     readonly registry: NotationRegistry;
     readonly notationInput: NotationRegistryInput;
     readonly specs: readonly NotationSpec[];
-    readonly catalog: CurriculumCatalog;
     readonly lintIgnore: LintIgnore;
-    /** Convention keys this course anchors on (from `content/course.config.ts`). */
-    readonly conventions: CourseConventions;
     /** This course's edits to the named-operator baseline (rule N8). */
     readonly operators?: CourseOperators;
     /** This course's edits to the roman-label baseline (rule N10). */

package/dist/reference/consistency.js

@@ -2,7 +2,8 @@ import { effectiveAccentAllowlist } from "./base-accents.mjs";
 import { effectiveOperatorAllowlist } from "./base-operators.mjs";
 import { effectiveRomanLabelAllowlist } from "./base-roman-labels.mjs";
 import { stripEquationLabels } from "./equations.mjs";
-import { pageScope } from "./gate-math.js";
+import { pageScope, scopeEntry } from "./gate-math.js";
+import { isIndexEntryLatex } from "../compiler/content-schemas.js";
 import {
   collectDecorations,
   collectOperators,
@@ -12,12 +13,12 @@ import {
   resolveMathGlyphs
 } from "./math-glyphs.mjs";
 import { offVocabularyTokens } from "./units-vocab.js";
-const CONVENTION_RE = /\bsign convention\b|\bcash-flow perspective\b|\bholder(?:'s)?(?:\s+\w+){0,2}\s+perspective\b|\bfrom (?:a|one|the|its)(?:\s+\w+){0,3}\s+perspective\b|\breverses? every sign\b|\bpositive (?:means|amounts?)\b/i;
+import { blankPropStrings } from "./gate-prop-text.js";
 function stripCode(text) {
   return text.replace(/```[\s\S]*?```/g, (block) => block.replace(/[^\n]/g, " ")).replace(/(^|[^`])`[^`\n]*`/g, (match) => match.replace(/[^\n]/g, " "));
 }
 function mathSpans(body) {
-  const searchable = stripCode(body);
+  const searchable = stripCode(blankPropStrings(body));
   const spans = [];
   for (const match of searchable.matchAll(/\$\$([\s\S]+?)\$\$/g)) {
     spans.push({ latex: stripEquationLabels(match[1] ?? "") });
@@ -79,6 +80,7 @@ function checkGlyphUniqueness(input, out) {
 }
 function checkNotationUnits(input, out) {
   for (const spec of input.specs) {
+    if (isIndexEntryLatex(spec.latex)) continue;
     if (spec.units === void 0 && !spec.dimensionless) {
       if (input.lintIgnore.matches("notation-units", spec.key)) continue;
       out.push({
@@ -105,35 +107,6 @@ function checkNotationUnits(input, out) {
     });
   }
 }
-function checkConventionSingleDefinition(input, out) {
-  const lessonById = new Map(
-    input.catalog.lessons.map((lesson) => [lesson.id, lesson])
-  );
-  for (const lesson of input.notationInput.lessons) {
-    const body = lesson.body;
-    if (!CONVENTION_RE.test(body)) continue;
-    const meta = lessonById.get(lesson.lessonId);
-    const { signConventionKey, cashFlowPerspectiveCompetency } = input.conventions;
-    const anchoredByCompetency = [
-      ...meta?.teaches ?? [],
-      ...meta?.requires ?? []
-    ].includes(cashFlowPerspectiveCompetency);
-    const anchoredByTerm = new RegExp(
-      `\\[\\[\\s*${signConventionKey}\\s*\\]\\]`
-    ).test(body);
-    if (anchoredByCompetency || anchoredByTerm) continue;
-    if (input.lintIgnore.matches("convention-single-definition", lesson.lessonId)) {
-      continue;
-    }
-    out.push({
-      code: "convention-single-definition",
-      severity: "warning",
-      lessonId: lesson.lessonId,
-      file: lesson.source.file,
-      message: `${lesson.lessonId} states a sign / cash-flow-perspective convention in prose but does not resolve it to a single declaration ([[${signConventionKey}]] or ${cashFlowPerspectiveCompetency})`
-    });
-  }
-}
 function checkWeakLocal(input, out) {
   for (const lesson of input.notationInput.lessons) {
     const spans = mathSpans(lesson.body).map((span) => span.latex);
@@ -295,7 +268,7 @@ function checkOperatorExplained(input, out) {
           lessonId: lesson.lessonId,
           file: lesson.source.file,
           glyph: operator.name,
-          message: `${lesson.lessonId}: operator ${JSON.stringify(display)} is neither on the course operator allowlist nor explained by a notation entry; give it a card or notation.local entry (latex ${JSON.stringify(display)}) introduced with [[key]], or add ${JSON.stringify(operator.name)} to operators.allow in course.config.ts`
+          message: `${lesson.lessonId}: operator ${JSON.stringify(display)} is neither on the course operator allowlist nor explained by a notation entry; give it a card or notation.local entry (latex ${JSON.stringify(display)}) introduced with [[key]], or add ${JSON.stringify(operator.name)} to rules.N8.allow in the course config (course.config.ts, or the course.settings.json it reads)`
         });
       }
     }
@@ -339,7 +312,7 @@ function checkRomanLabelExplained(input, out) {
           lessonId: lesson.lessonId,
           file: lesson.source.file,
           glyph: label.name,
-          message: `${lesson.lessonId}: roman label ${JSON.stringify(`\\mathrm{${label.name}}`)} is neither on the course roman-label allowlist nor explained by a notation entry; give it a card or notation.local entry (latex ${JSON.stringify(`\\mathrm{${label.name}}`)}) introduced with [[key]], or add ${JSON.stringify(label.name)} to romanLabels.allow in course.config.ts`
+          message: `${lesson.lessonId}: roman label ${JSON.stringify(`\\mathrm{${label.name}}`)} is neither on the course roman-label allowlist nor explained by a notation entry; give it a card or notation.local entry (latex ${JSON.stringify(`\\mathrm{${label.name}}`)}) introduced with [[key]], or add ${JSON.stringify(label.name)} to rules.N10.allow in the course config (course.config.ts, or the course.settings.json it reads)`
         });
       }
     }
@@ -349,7 +322,7 @@ function sharedScopeByKey(input) {
   return new Map(
     input.notationInput.sharedDefinitions.map((definition) => [
       definition.key,
-      { key: definition.key, notation: definition.notation }
+      scopeEntry(definition)
     ])
   );
 }
@@ -363,11 +336,35 @@ function checkAccentExplained(input, out) {
     for (const span of mathSpans(lesson.body)) {
       let decorations;
       try {
-        ({ decorations } = resolveMathGlyphs(span.latex, scope, { suspended }));
+        ({ decorations } = resolveMathGlyphs(span.latex, scope, {
+          suspended,
+          derive: true
+        }));
       } catch {
         continue;
       }
       for (const decoration of decorations) {
+        if (decoration.wholeForm !== null && decoration.wholeFormExplicit) {
+          const notation = scope.find((entry) => entry.key === decoration.wholeForm)?.notation ?? "";
+          const carries = collectDecorations(notation).some(
+            (item) => item.name === decoration.name
+          );
+          const id = `swallowed:${decoration.token}`;
+          if (!carries && !reported.has(id)) {
+            reported.add(id);
+            if (!input.lintIgnore.matches("accent-swallowed", decoration.name)) {
+              out.push({
+                code: "accent-swallowed",
+                severity: "warning",
+                lessonId: lesson.lessonId,
+                file: lesson.source.file,
+                glyph: decoration.name,
+                message: `${lesson.lessonId}: \\explain{${decoration.wholeForm}}{${decoration.token}} wraps the decoration ${JSON.stringify(decoration.name)} in ${decoration.wholeForm}, whose latex (${notation}) has none, so its card cannot explain it; wrap only the symbol under it and give the decoration an operator entry (latex ${JSON.stringify(operatorEntryLatex(decoration.name))}), or name an entry for the decorated form (latex ${JSON.stringify(decoration.token)})`
+              });
+            }
+          }
+          continue;
+        }
         if (decoration.wholeForm !== null || decoration.operator !== null) continue;
         if (suspended.includes(decoration.name)) continue;
         if (allowlist.has(decoration.name)) continue;
@@ -436,7 +433,6 @@ function checkOperatorSuspension(input, out) {
 const CHECKS = [
   checkGlyphUniqueness,
   checkNotationUnits,
-  checkConventionSingleDefinition,
   checkWeakLocal,
   checkNotationSourceLocator,
   checkGlossWantsPromoting,
@@ -459,7 +455,6 @@ function consistencyCounts(diagnostics) {
     "glyph-unique-in-corpus": 0,
     "notation-units": 0,
     "units-vocab": 0,
-    "convention-single-definition": 0,
     "weak-local": 0,
     "notation-source-locator": 0,
     "gloss-wants-promoting": 0,
@@ -468,6 +463,7 @@ function consistencyCounts(diagnostics) {
     "operator-explained": 0,
     "roman-label-explained": 0,
     "accent-explained": 0,
+    "accent-swallowed": 0,
     "operator-suspended": 0,
     "operator-suspension-reason": 0,
     "operator-shadowed": 0

package/dist/reference/curriculum-alignment.js

@@ -2,13 +2,10 @@ import { compareDiagnostics } from "./references.js";
 function validateNotationAlignment(registry, catalog) {
   const diagnostics = [];
   const competencies = new Map(
-    catalog.competencies.map((entry) => [
-      entry.id,
-      entry
-    ])
+    catalog.competencies.map((entry) => [entry.id, entry])
   );
   const lessons = new Map(catalog.lessons.map((entry) => [entry.id, entry]));
-  const sources = new Map(catalog.sources.map((entry) => [entry.id, entry]));
+  const sources = new Set(catalog.sources.map((entry) => entry.id));
   const trackPositions = buildTrackPositions(catalog, diagnostics);
   for (const definition of registry.definitions) {
     validateSources(definition, sources, diagnostics);
@@ -60,15 +57,6 @@ function validateNotationAlignment(registry, catalog) {
       trackPositions,
       diagnostics
     );
-    if (definition.status === "reviewed" && (lesson.status !== "reviewed" || competency?.editorialStatus !== "reviewed")) {
-      diagnostics.push(
-        error(
-          "alignment-review-state",
-          `${definition.id} is reviewed while its owning lesson or competency is not reviewed`,
-          definition
-        )
-      );
-    }
   }
   return diagnostics.sort(compareDiagnostics);
 }
@@ -129,8 +117,7 @@ function validateIntroductionOrder(definition, introductionLessonId, registry, t
 }
 function validateSources(definition, sources, diagnostics) {
   for (const sourceId of definition.sources) {
-    const source = sources.get(sourceId);
-    if (!source) {
+    if (!sources.has(sourceId)) {
       diagnostics.push(
         error(
           "alignment-unavailable",
@@ -138,14 +125,6 @@ function validateSources(definition, sources, diagnostics) {
           definition
         )
       );
-    } else if (definition.status === "reviewed" && source.editorialStatus !== "reviewed") {
-      diagnostics.push(
-        error(
-          "alignment-review-state",
-          `${definition.id} is reviewed while source ${sourceId} is ${source.editorialStatus}`,
-          definition
-        )
-      );
     }
   }
 }

package/dist/reference/derived-entries.d.ts

@@ -0,0 +1,45 @@
+import { ManifestDerivedNotation } from '../compiler/manifest.js';
+import { GlyphScopeEntry } from './gloss.js';
+import { DerivedUse, NotationDefinitionRecord } from './types.js';
+import '../curriculum/validation.js';
+import './consistency.js';
+import '../course-config-rRtME5UV.js';
+import '../rules/catalog.js';
+import '../rules/course-rules.js';
+import '../compiler/collections.js';
+import './gate-retired-keys.js';
+import './lint-ignore.js';
+import './equations-validate.js';
+import './tables-validate.js';
+import './keyed-float-validate.js';
+import './figures-validate.js';
+import './diagrams-validate.js';
+import './examples-validate.js';
+import './folds-validate.js';
+import './knowledge-checks-validate.js';
+import './raw-floats-validate.js';
+import './lab-katex-validate.js';
+import './gate-math.js';
+import './mixed-content.js';
+import '../rules/waivers.js';
+import '../compiler/knowledge-version.js';
+import '../compiler/lesson-derivation.js';
+
+/**
+ * Derived cards (rule N23) as the page payload carries them: each derived
+ * card a page's math uses, composed from its base and index entries by
+ * `derived-notation.mjs`, with the glyph table its formula resolves against.
+ * The manifest builds the ones lesson-body and assessment math use; the page
+ * payload (`page-notation.ts`) builds the ones a lab or a diagram registers
+ * while it renders, the same way.
+ */
+
+/**
+ * The derived cards for `uses`, sorted by key. `records` holds the page's
+ * entries by key, local ones winning; a use whose base or index entry is not
+ * there is skipped. A card's formula resolves against the derived symbol,
+ * the index entry's glosses, the base, and the cards the formula names.
+ */
+declare function derivedNotationEntries(uses: readonly DerivedUse[], records: ReadonlyMap<string, NotationDefinitionRecord>, cardsByKey: ReadonlyMap<string, GlyphScopeEntry>): ManifestDerivedNotation[];
+
+export { derivedNotationEntries };