explico 0.13.1 → 0.15.0

package/dist/compiler/validate-content.js

@@ -0,0 +1,160 @@
+import { notationSourceLocatorGaps } from "./collections.js";
+import { createRunLog, diagnosticLine } from "./logging.js";
+import { compileManifest, MANIFEST_PATH, writeManifest } from "./manifest.js";
+import { syncPageVersions } from "./page-versions.js";
+import { syncResolutionReports } from "./resolution-report.js";
+import { consistencyCounts } from "../reference/consistency.js";
+import { curriculumErrors } from "../curriculum/validation.js";
+import { writeRulesInEffect } from "../rules/in-effect.js";
+async function runValidateContent(courseConfig) {
+  const log = createRunLog();
+  let manifest;
+  try {
+    manifest = await compileManifest(courseConfig);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error("manifest", `Manifest compilation failed: ${message}`);
+    const summary2 = log.close();
+    console.error(`Manifest compilation failed: ${message}
+Run log: ${summary2.relativeDirectory}.`);
+    return 1;
+  }
+  writeManifest(manifest);
+  const {
+    curriculum,
+    notation,
+    alignment,
+    math,
+    consistency,
+    equations,
+    tables,
+    figures,
+    diagrams,
+    checks,
+    examples,
+    folds,
+    knowledge,
+    rawFloats,
+    config,
+    waivers
+  } = manifest.diagnostics;
+  for (const warning of curriculum.filter((issue) => issue.severity === "warning")) {
+    console.warn(log.warning("curriculum", `[${warning.kind}] ${warning.message}`));
+  }
+  for (const warning of notation.filter((d) => d.severity === "warning")) {
+    console.warn(log.warning("notation", `[${warning.code}] ${warning.message}`));
+  }
+  for (const warning of alignment.filter((d) => d.severity === "warning")) {
+    console.warn(log.warning("alignment", `[${warning.code}] ${warning.message}`));
+  }
+  const floatGroups = [
+    ["equations", equations],
+    ["tables", tables],
+    ["figures", figures],
+    ["diagrams", diagrams],
+    ["checks", checks],
+    ["examples", examples],
+    ["folds", folds],
+    ["rawFloats", rawFloats]
+  ];
+  for (const [source, group] of floatGroups) {
+    for (const warning of group.filter((d) => d.severity === "warning")) {
+      console.warn(log.warning(source, `[${warning.code}] ${warning.message}`));
+    }
+  }
+  for (const issue of math.filter((item) => item.severity === "warning")) {
+    console.warn(log.warning("math", diagnosticLine(issue)));
+  }
+  for (const warning of knowledge) {
+    console.warn(log.warning("knowledge", `[${warning.code}] ${warning.message}`));
+  }
+  for (const warning of config) {
+    console.warn(log.warning("config", `[${warning.code}] ${warning.message}`));
+  }
+  for (const warning of waivers.filter((d) => d.severity === "warning")) {
+    console.warn(log.warning("waivers", diagnosticLine(warning)));
+  }
+  const locatorGaps = notationSourceLocatorGaps();
+  if (locatorGaps.bare > 0) {
+    console.warn(
+      log.warning(
+        "consistency",
+        `[notation-source-locator] ${locatorGaps.bare} of ${locatorGaps.total} notation source citations lack a non-empty locator.`
+      )
+    );
+  }
+  const consistencyWarnings = consistency.filter((diagnostic) => diagnostic.severity === "warning");
+  if (consistencyWarnings.length > 0) {
+    console.warn(
+      log.info(
+        "consistency",
+        `[consistency] ${consistencyWarnings.length} Tier-3 finding(s): ` + Object.entries(consistencyCounts(consistencyWarnings)).filter(([, count]) => count > 0).map(([code, count]) => `${code}=${count}`).join(", ")
+      )
+    );
+  }
+  log.infoDiagnostics(manifest.diagnostics);
+  for (const diagnostic of consistencyWarnings) {
+    log.warning("consistency", `[${diagnostic.code}] ${diagnostic.message}`);
+  }
+  const reports = syncResolutionReports(manifest);
+  console.log(
+    log.info(
+      "manifest",
+      `Resolution report: ${reports.written} file(s) under resolution/` + (reports.refreshed.length > 0 ? ` (${reports.refreshed.length} refreshed; git does not track them, nothing to commit).` : ".")
+    )
+  );
+  const pageVersions = syncPageVersions(manifest);
+  if (pageVersions.written) {
+    console.log(
+      log.info(
+        "page-versions",
+        `content/versions.json ${pageVersions.changed[0] === "*" ? "written" : `updated for ${pageVersions.changed.length} page(s)`} \u2014 commit it with the change (rule C5).`
+      )
+    );
+  }
+  writeRulesInEffect(manifest);
+  console.log(
+    log.info("manifest", `Rules in effect: build/rules-in-effect.md (${manifest.rules.disabled.length} rule(s) off).`)
+  );
+  const failures = [];
+  const block = (source, message) => {
+    failures.push(log.error(source, message));
+  };
+  for (const stalePath of reports.stale) {
+    block("resolution-report", `[resolution-report] ${stalePath} is out of date \u2014 commit the regenerated resolution/ files`);
+  }
+  if (pageVersions.diagnostic) block("page-versions", diagnosticLine(pageVersions.diagnostic));
+  for (const issue of curriculumErrors(curriculum)) block("curriculum", `[curriculum:${issue.kind}] ${issue.message}`);
+  for (const issue of notation.filter((d) => d.severity === "error")) block("notation", `[notation:${issue.code}] ${issue.message}`);
+  for (const issue of alignment.filter((d) => d.severity === "error")) block("alignment", `[alignment:${issue.code}] ${issue.message}`);
+  for (const issue of math.filter((item) => item.severity === "error")) block("math", diagnosticLine(issue));
+  for (const issue of waivers.filter((d) => d.severity === "error")) block("waivers", diagnosticLine(issue));
+  for (const [source, group] of floatGroups) {
+    for (const issue of group.filter((d) => d.severity === "error")) block(source, `[${issue.code}] ${issue.message}`);
+  }
+  if (failures.length > 0) {
+    const summary2 = log.close();
+    console.error(
+      `Content manifest has ${failures.length} blocking diagnostic(s):
+${failures.map((line) => `- ${line}`).join("\n")}
+Run log: ${summary2.relativeDirectory} (${summary2.counts.ERROR} error(s), ${summary2.counts.WARNING} warning(s)).`
+    );
+    return 1;
+  }
+  const itemCount = manifest.lessons.reduce((count, lesson) => count + lesson.assessments.length, 0);
+  const relPath = MANIFEST_PATH.replace(`${process.cwd()}/`, "");
+  console.log(
+    log.info(
+      "manifest",
+      `Manifest written to ${relPath} (schema v${manifest.schemaVersion}, knowledge v${manifest.about.knowledge.version}): ${manifest.competencies.length} competencies, ${manifest.lessons.length} lessons, ${itemCount} lesson assessment links, ${manifest.notation.definitions.length} notation definitions, ${manifest.sources.length} sources, ${manifest.tracks.length} track(s). Content fingerprint ${manifest.hashes.contentTree}.`
+    )
+  );
+  const summary = log.close();
+  console.log(
+    `Run log: ${summary.relativeDirectory} (${summary.counts.ERROR} error(s), ${summary.counts.WARNING} warning(s), ${summary.counts.INFO} info).`
+  );
+  return 0;
+}
+export {
+  runValidateContent
+};

package/dist/{course-config-rRtME5UV.d.ts → course-config-BLtIdkei.d.ts}

@@ -382,6 +382,154 @@ interface NormalizedCards {
 declare const CARDS_DEFAULTS: NormalizedCards;
 /** Validate `CourseConfig.cards` and apply its defaults. Throws on a bad value. */
 declare function normalizeCards(config: CourseConfig): NormalizedCards;
+/**
+ * The marks the sidebar puts beside a chapter or part page for one reader
+ * (`sidebarMarks` in the course settings, `page-marks.ts`): a quiet ring
+ * while they have not opened it, an accent dot when its content changed
+ * since they last did. Every field is optional; {@link normalizeSidebarMarks}
+ * fills in the defaults.
+ */
+interface CourseSidebarMarks {
+    /** Mark a page the reader has not opened yet. Default `true`. */
+    readonly unopened?: boolean;
+    /** Mark a page whose content changed since the reader last opened it. Default `true`. */
+    readonly changed?: boolean;
+}
+/** {@link CourseSidebarMarks} with every default applied. */
+interface NormalizedSidebarMarks {
+    readonly unopened: boolean;
+    readonly changed: boolean;
+}
+declare const SIDEBAR_MARKS_DEFAULTS: NormalizedSidebarMarks;
+/** Validate `CourseConfig.sidebarMarks` and apply its defaults. Throws on a bad value. */
+declare function normalizeSidebarMarks(config: CourseConfig): NormalizedSidebarMarks;
+/**
+ * Which edition of a lesson its sidebar row opens, for a reader who has not
+ * chosen (`sidebarEditions` in the course settings, `sidebar-editions.ts`). A
+ * lesson with a chapter and a deck is one row: the row opens the **lead**
+ * edition, and the **other** is an icon at the row's end, or not listed. A
+ * reader switches both in the sidebar's foot. The plain `string` fields
+ * arrive as JSON; {@link normalizeSidebarEditions} rejects any value it does
+ * not list.
+ */
+interface CourseSidebarEditions {
+    /** The edition a lesson's row opens: `chapter` (default) or `slides`. */
+    readonly lead?: string;
+    /** Whether the row also lists the other edition: `listed` (default) or `hidden`. */
+    readonly other?: string;
+}
+type SidebarEditionLead = 'chapter' | 'slides';
+type SidebarEditionOther = 'listed' | 'hidden';
+/** {@link CourseSidebarEditions} with every default applied. */
+interface NormalizedSidebarEditions {
+    readonly lead: SidebarEditionLead;
+    readonly other: SidebarEditionOther;
+}
+/** The engine's defaults (decision D10): the chapter leads, the slides are listed. */
+declare const SIDEBAR_EDITIONS_DEFAULTS: NormalizedSidebarEditions;
+/** Validate `CourseConfig.sidebarEditions` and apply its defaults. Throws on a bad value. */
+declare function normalizeSidebarEditions(config: CourseConfig): NormalizedSidebarEditions;
+/**
+ * A course's decks: the slide edition of a lesson (`<lesson>.deck.mdx`,
+ * `docs/authoring/deck.md`). Every field is optional; {@link normalizeDeck}
+ * fills in the defaults. The plain `string` fields arrive as JSON, and
+ * {@link normalizeDeck} rejects any value it does not list.
+ */
+interface CourseDeck {
+    /**
+     * The canvas every deck of the course is laid out on: `16:9` (default),
+     * `16:10` or `4:3`. One setting for the course, because the frame-fit check,
+     * the captured figures and the PDF's page all read it.
+     */
+    readonly aspectRatio?: string;
+    /**
+     * The line on a frame that names the symbols it shows: `first-use`
+     * (default, the symbols the deck has not shown before), `every-frame`
+     * (every symbol on the frame), or `off`.
+     */
+    readonly legend?: string;
+    /**
+     * Who sees a frame's speaker notes: `reader` (default — under each frame in
+     * the scroll view, in the presenter window and in the handout), `presenter`
+     * (the presenter window and the handout only), or `off` (nowhere; the
+     * handout PDF is not built).
+     */
+    readonly notes?: string;
+    /** End each deck on a frame of what its lesson's competencies say a student can now do. Default `true`. */
+    readonly outcomesFrame?: boolean;
+    /** Offer the slides-with-notes PDF beside the slides PDF. Default `true`. */
+    readonly handoutPdf?: boolean;
+}
+type DeckAspectRatio = '16:9' | '16:10' | '4:3';
+type DeckLegend = 'first-use' | 'every-frame' | 'off';
+type DeckNotes = 'reader' | 'presenter' | 'off';
+/**
+ * The logical canvas a frame is laid out on, in CSS pixels: the width of the
+ * page's reading column, so a figure, a table or a lab lays out on a frame at
+ * the size it was made for, and the frame is scaled to the screen. Every
+ * ratio is 450 px tall, so the type scale and a frame's capacity in lines are
+ * the same in all three. Printed, the canvas is scaled by 1.6 onto a page
+ * 7.5 in tall (13.333 × 7.5 in for 16:9).
+ */
+declare const DECK_CANVAS: Readonly<Record<DeckAspectRatio, {
+    readonly width: number;
+    readonly height: number;
+}>>;
+/** {@link CourseDeck} with every default applied, as the manifest publishes it. */
+interface NormalizedDeck {
+    readonly aspectRatio: DeckAspectRatio;
+    readonly legend: DeckLegend;
+    readonly notes: DeckNotes;
+    readonly outcomesFrame: boolean;
+    readonly handoutPdf: boolean;
+    readonly canvas: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+declare const DECK_DEFAULTS: Omit<NormalizedDeck, 'canvas'>;
+/** Validate `CourseConfig.deck` and apply its defaults. Throws on a bad value. */
+declare function normalizeDeck(config: CourseConfig): NormalizedDeck;
+/**
+ * Whether the course asks each reader if it may remember their reading in
+ * their browser (`readingMemory` in the course settings,
+ * `session/reading-memory.ts`): which chapters they opened (the sidebar's
+ * marks) and the cards they keep or carry, across visits. `ask` (default)
+ * shows the question until the reader answers; `off` never asks and never
+ * keeps reading memory, so the marks are off and cards last as long as the tab.
+ */
+type ReadingMemorySetting = 'ask' | 'off';
+/** Validate `CourseConfig.readingMemory`. Throws on a bad value. */
+declare function normalizeReadingMemory(config: CourseConfig): ReadingMemorySetting;
+/**
+ * How the page tells its zones apart, and how a deck's slides sit on it
+ * (`appearance` in the course settings; `zones.css` and `deck.css` hold the
+ * colours). `zones`: `tonal` (the default) gives both sidebars one step of the
+ * neutral grey and the header a step further; `accent-header` makes the
+ * header a deep band of the course accent; `paper` lays the reading column
+ * on the sidebars' colour as a sheet; `none` keeps Starlight's colours.
+ * `slides`: `lifted` (the default) gives each slide an edge and a drop
+ * shadow, and in the dark theme a sheet a step lighter than the page; `edge`
+ * the edge and shadow on the page's own colour; `sorter` lays the deck on a
+ * tinted well. Every field is optional; {@link normalizeAppearance} fills in
+ * the defaults.
+ */
+interface CourseAppearance {
+    /** `tonal` (default), `accent-header`, `paper` or `none`. */
+    readonly zones?: string;
+    /** `lifted` (default), `edge` or `sorter`. */
+    readonly slides?: string;
+}
+type AppearanceZones = 'tonal' | 'accent-header' | 'paper' | 'none';
+type AppearanceSlides = 'lifted' | 'edge' | 'sorter';
+/** {@link CourseAppearance} with every default applied. */
+interface NormalizedAppearance {
+    readonly zones: AppearanceZones;
+    readonly slides: AppearanceSlides;
+}
+declare const APPEARANCE_DEFAULTS: NormalizedAppearance;
+/** Validate `CourseConfig.appearance` and apply its defaults. Throws on a bad value. */
+declare function normalizeAppearance(config: CourseConfig): NormalizedAppearance;
 /**
  * Rule S2's word ranges (`rules.S2.bridgeMinWords` … in the course settings),
  * in the shape `gate-part-pages.ts` takes. Built by `partPageLimits` in
@@ -487,6 +635,21 @@ interface CourseConfig {
     readonly numbering?: CourseNumbering;
     /** How explanation cards start for a reader: "Carry cards" on or off. */
     readonly cards?: CourseCards;
+    /** The sidebar's marks for a page the reader has not opened, or that changed since. */
+    readonly sidebarMarks?: CourseSidebarMarks;
+    /** Which edition a lesson's sidebar row opens, and whether it lists the other. */
+    readonly sidebarEditions?: CourseSidebarEditions;
+    /** How the course's decks look and what they show (`docs/authoring/deck.md`). */
+    readonly deck?: CourseDeck;
+    /**
+     * Ask each reader whether the course may remember their reading in their
+     * browser (`ask`, the default), or never keep it (`off`). A plain `string`
+     * because the settings arrive as JSON; {@link normalizeReadingMemory}
+     * rejects any other value.
+     */
+    readonly readingMemory?: string;
+    /** How the page tells header, sidebars and article apart, and how slides sit on it. */
+    readonly appearance?: CourseAppearance;
     /**
      * How a check's and an example set's heading names its kind: `icon-word`
      * (default) or `icon` ({@link BlockLabels}). A plain `string` because the
@@ -504,4 +667,4 @@ declare function normalizeLessonExports(config: CourseConfig): NormalizedLessonE
  */
 declare function coursePartsOf(config: CourseConfig): readonly CoursePart[];
 
-export { type CourseOpenDefault as A, type BlockLabels as B, type CourseConfig as C, type CoursePart as D, type CourseSection as E, DISCLOSURE_DEFAULTS as F, coursePartsOf as G, normalizeBlockLabels as H, normalizeCards as I, normalizeDisclosure as J, normalizeLessonExports as K, type LessonExportsConfig as L, type ManifestRules as M, type NormalizedLessonExports as N, normalizeNumbering as O, type ResolvedRules as R, type NormalizedDisclosure as a, type NormalizedNumbering as b, type NormalizedCards as c, type ConfigDiagnostic as d, type CourseOperators as e, type CourseRomanLabels as f, type CourseAccents as g, type CourseAbbreviations as h, type NormalizedPartPages as i, type CourseRulesConfig as j, type RuleSettingsInput as k, catalogIds as l, disabledCodes as m, dropDisabled as n, rulesJsonSchema as o, partPageLimits as p, rulesSnapshot as q, resolveRules as r, BLOCK_LABELS_DEFAULT as s, CARDS_DEFAULTS as t, type CourseAbout as u, type CourseAuthor as v, type CourseCards as w, type CourseDisclosure as x, type CourseHeadingDisclosure as y, type CourseNumbering as z };
+export { SIDEBAR_EDITIONS_DEFAULTS as $, APPEARANCE_DEFAULTS as A, type BlockLabels as B, type CourseConfig as C, CARDS_DEFAULTS as D, type CourseAbout as E, type CourseAppearance as F, type CourseAuthor as G, type CourseCards as H, type CourseDeck as I, type CourseDisclosure as J, type CourseHeadingDisclosure as K, type CourseNumbering as L, type ManifestRules as M, type NormalizedLessonExports as N, type CourseOpenDefault as O, type CoursePart as P, type CourseSection as Q, type ReadingMemorySetting as R, type CourseSidebarEditions as S, type CourseSidebarMarks as T, DECK_CANVAS as U, DECK_DEFAULTS as V, DISCLOSURE_DEFAULTS as W, type DeckAspectRatio as X, type DeckLegend as Y, type DeckNotes as Z, type LessonExportsConfig as _, type NormalizedDisclosure as a, SIDEBAR_MARKS_DEFAULTS as a0, type SidebarEditionLead as a1, type SidebarEditionOther as a2, coursePartsOf as a3, normalizeAppearance as a4, normalizeBlockLabels as a5, normalizeCards as a6, normalizeDeck as a7, normalizeDisclosure as a8, normalizeLessonExports as a9, normalizeNumbering as aa, normalizeReadingMemory as ab, normalizeSidebarEditions as ac, normalizeSidebarMarks as ad, type NormalizedNumbering as b, type NormalizedCards as c, type NormalizedSidebarMarks as d, type NormalizedSidebarEditions as e, type NormalizedAppearance as f, type NormalizedDeck as g, type ConfigDiagnostic as h, type CourseOperators as i, type CourseRomanLabels as j, type CourseAccents as k, type CourseAbbreviations as l, type NormalizedPartPages as m, type CourseRulesConfig as n, type ResolvedRules as o, type RuleSettingsInput as p, catalogIds as q, disabledCodes as r, dropDisabled as s, partPageLimits as t, resolveRules as u, rulesJsonSchema as v, rulesSnapshot as w, type AppearanceSlides as x, type AppearanceZones as y, BLOCK_LABELS_DEFAULT as z };

package/dist/curriculum/competency-graph.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The competency dependency graph, cut into one piece per part
+ * (`<CurriculumMap graph="per-part">`).
+ *
+ * The whole-course graph is one diagram, and a course with many competencies
+ * lays it out far wider than the lesson column (rule V8) — narrower boxes do
+ * not help, since the widest rank holds a dozen competencies. One diagram per
+ * part keeps each to the competencies a reader meets together.
+ */
+interface GraphNode {
+    readonly id: string;
+    readonly text: string;
+}
+interface GraphEdge {
+    readonly from: string;
+    readonly to: string;
+}
+interface PartGraph {
+    /** The diagram's id, unique on the page: `competency-graph-<part dir>`. */
+    readonly id: string;
+    /** The part's overview title, its label when it has none; the untaught group's name. */
+    readonly title: string;
+    /** The competencies this group teaches, then one box per earlier competency they build on. */
+    readonly nodes: readonly GraphNode[];
+    /** An arrow from each prerequisite to a competency the group teaches. */
+    readonly edges: readonly GraphEdge[];
+}
+interface PartInput {
+    readonly dir: string;
+    readonly label: string;
+    /** Lesson ids in chapter order. */
+    readonly lessons: readonly string[];
+    readonly overview?: {
+        readonly title: string;
+    };
+}
+interface CompetencyInput {
+    readonly id: string;
+    readonly title: string;
+    readonly prerequisites: readonly string[];
+}
+declare const UNTAUGHT_GRAPH_ID = "competency-graph-untaught";
+declare const UNTAUGHT_TITLE = "Competencies no lesson teaches";
+/**
+ * One graph per part, in `parts` order, then a last one for competencies no
+ * lesson teaches, so every competency is drawn once as a taught box. A
+ * competency belongs to the first part whose lessons teach it. A prerequisite
+ * taught in another part is drawn in this one as a box labelled
+ * `<part label>: <title>`, so the arrow into the competency still shows.
+ * A part that teaches no competency has no graph.
+ */
+declare function competencyGraphsByPart(parts: readonly PartInput[], teachesByLesson: ReadonlyMap<string, readonly string[]>, competencies: readonly CompetencyInput[]): PartGraph[];
+
+export { type CompetencyInput, type GraphEdge, type GraphNode, type PartGraph, type PartInput, UNTAUGHT_GRAPH_ID, UNTAUGHT_TITLE, competencyGraphsByPart };

package/dist/curriculum/competency-graph.js

@@ -0,0 +1,41 @@
+const UNTAUGHT_GRAPH_ID = "competency-graph-untaught";
+const UNTAUGHT_TITLE = "Competencies no lesson teaches";
+function competencyGraphsByPart(parts, teachesByLesson, competencies) {
+  const partOf = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    for (const lessonId of part.lessons) {
+      for (const id of teachesByLesson.get(lessonId) ?? []) {
+        if (!partOf.has(id)) partOf.set(id, part);
+      }
+    }
+  }
+  const titleOf = new Map(competencies.map((competency) => [competency.id, competency.title]));
+  const graphs = [];
+  for (const part of [...parts, void 0]) {
+    const taught = competencies.filter((competency) => partOf.get(competency.id) === part);
+    if (taught.length === 0) continue;
+    const earlier = [...new Set(taught.flatMap((competency) => competency.prerequisites))].filter(
+      (id) => partOf.get(id) !== part
+    );
+    graphs.push({
+      id: part ? `competency-graph-${part.dir.replace(/[^A-Za-z0-9_-]/g, "-")}` : UNTAUGHT_GRAPH_ID,
+      title: part ? part.overview?.title ?? part.label : UNTAUGHT_TITLE,
+      nodes: [
+        ...taught.map((competency) => ({ id: competency.id, text: competency.title })),
+        ...earlier.map((id) => ({
+          id,
+          text: `${partOf.get(id)?.label ?? "Not taught"}: ${titleOf.get(id) ?? id}`
+        }))
+      ],
+      edges: taught.flatMap(
+        (competency) => competency.prerequisites.map((from) => ({ from, to: competency.id }))
+      )
+    });
+  }
+  return graphs;
+}
+export {
+  UNTAUGHT_GRAPH_ID,
+  UNTAUGHT_TITLE,
+  competencyGraphsByPart
+};

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

@@ -1,5 +1,11 @@
 /** True when `token` is a base-library atom and needs no semantic key. */
 export function isBaseLibraryAtom(token: any): boolean;
+/**
+ * True when `glyph`, as a rendered page shows it, is a base-library atom. The
+ * rendered-page check (`figure-symbols.ts`) reads glyphs, not LaTeX, and
+ * exempts the same library the math gates do.
+ */
+export function isBaseLibraryGlyph(glyph: any): boolean;
 /**
  * The base notation library: a small, fixed set of universal identifier atoms
  * that the page-level glyph map never asks an author to declare.
@@ -15,3 +21,5 @@ export function isBaseLibraryAtom(token: any): boolean;
  * atoms, so the tokenizer never treats them as bindable symbols.
  */
 export const BASE_LIBRARY: Readonly<Set<string>>;
+/** What KaTeX draws for each base-library atom: `d`, `e`, `i`, `π`. */
+export const BASE_LIBRARY_GLYPHS: Readonly<Set<any>>;

package/dist/reference/base-library.mjs

@@ -25,3 +25,22 @@ export const BASE_LIBRARY = Object.freeze(
 export function isBaseLibraryAtom(token) {
   return BASE_LIBRARY.has(token);
 }
+
+// An atom's LaTeX is its own glyph unless it is a command: `\pi` draws `π`.
+// `tests/notation/figure-symbols.test.ts` renders every atom and holds this
+// table to what KaTeX draws, so a new command atom cannot be forgotten here.
+const DRAWN_AS = Object.freeze({ '\\pi': 'π' });
+
+/** What KaTeX draws for each base-library atom: `d`, `e`, `i`, `π`. */
+export const BASE_LIBRARY_GLYPHS = Object.freeze(
+  new Set([...BASE_LIBRARY].map((atom) => DRAWN_AS[atom] ?? atom)),
+);
+
+/**
+ * True when `glyph`, as a rendered page shows it, is a base-library atom. The
+ * rendered-page check (`figure-symbols.ts`) reads glyphs, not LaTeX, and
+ * exempts the same library the math gates do.
+ */
+export function isBaseLibraryGlyph(glyph) {
+  return BASE_LIBRARY_GLYPHS.has(glyph);
+}

package/dist/reference/consistency.d.ts

@@ -1,4 +1,4 @@
-import { e as CourseOperators, f as CourseRomanLabels, g as CourseAccents } from '../course-config-rRtME5UV.js';
+import { i as CourseOperators, j as CourseRomanLabels, k as CourseAccents } from '../course-config-BLtIdkei.js';
 import { NotationSpec } from '../compiler/collections.js';
 import { LintIgnore } from './lint-ignore.js';
 import { NotationRegistry, NotationRegistryInput } from './types.js';
@@ -18,7 +18,10 @@ import './gate-retired-keys.js';
  * 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
+ *   (a) glyph-unique-in-corpus       one rendered glyph → one shared meaning; a
+ *                                    local card or a gloss may reuse a letter
+ *   (a') definition-repeated         one local key declared in two lessons
+ *   (a'') meaning-repeated           one symbol and name defined at two sites, any tier
  *   (b) notation-units / units-vocab  every entry has units or `dimensionless`,
  *                                     unit strings drawn from a controlled vocab
  *   (f) weak-local                  a `notation.local` symbol used only in its
@@ -44,7 +47,7 @@ import './gate-retired-keys.js';
  * `src/content/resolution-report.ts`.
  */
 
-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';
+type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'weak-local' | 'notation-source-locator' | 'definition-repeated' | 'meaning-repeated' | '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. */
@@ -69,6 +72,7 @@ interface ConsistencyInput {
     /** This course's edits to the (empty) accent baseline (rule N22). */
     readonly accents?: CourseAccents;
 }
+declare function glyphMatcher(latex: string): RegExp | undefined;
 /**
  * Run every consistency check. The result is sorted deterministically (code,
  * then lesson / key / glyph, then message) so it is byte-stable in the manifest
@@ -78,4 +82,4 @@ declare function runConsistencyChecks(input: ConsistencyInput): ConsistencyDiagn
 /** `{ code: count }` for the CLI summary and the report header. */
 declare function consistencyCounts(diagnostics: readonly ConsistencyDiagnostic[]): Record<ConsistencyCode, number>;
 
-export { type ConsistencyCode, type ConsistencyDiagnostic, type ConsistencyInput, consistencyCounts, runConsistencyChecks };
+export { type ConsistencyCode, type ConsistencyDiagnostic, type ConsistencyInput, consistencyCounts, glyphMatcher, runConsistencyChecks };