explico 0.3.0 → 0.5.0

package/dist/compiler/lesson-derivation.d.ts

@@ -84,6 +84,6 @@ type SidebarGroup = {
  * merged track order (ties broken by slug), then the static Reference group.
  * Replaces seven `autogenerate` blocks that read an authored `sidebar.order`.
  */
-declare function buildSidebar(tracks: readonly TrackLike[], lessonSlugs: readonly string[], sections: readonly SidebarSection[]): SidebarGroup[];
+declare function buildSidebar(tracks: readonly TrackLike[], lessonSlugs: readonly string[], parts: readonly SidebarSection[]): SidebarGroup[];
 
 export { type SidebarGroup, type SidebarSection, buildSidebar, citedSourceIds, deriveRequires, deriveSources, isLessonSlug, lessonIdFromSlug, mergeTrackOrder, parseCheckList };

package/dist/compiler/lesson-derivation.js

@@ -59,12 +59,12 @@ function mergeTrackOrder(tracks) {
   }
   return ordered;
 }
-function buildSidebar(tracks, lessonSlugs, sections) {
+function buildSidebar(tracks, lessonSlugs, parts) {
   const rank = new Map(
     mergeTrackOrder(tracks).map((lessonId, index) => [lessonId, index])
   );
   const positionOf = (slug) => rank.get(lessonIdFromSlug(slug)) ?? Number.POSITIVE_INFINITY;
-  const groups = sections.map(({ dir, label }) => ({
+  const groups = parts.map(({ dir, label }) => ({
     label,
     items: lessonSlugs.filter((slug) => slug.startsWith(`${dir}/`)).sort(
       (left, right) => positionOf(left) - positionOf(right) || left.localeCompare(right)

package/dist/compiler/manifest.d.ts

@@ -3,10 +3,14 @@ import { ConsistencyDiagnostic } from '../reference/consistency.js';
 import { EquationLabelRecord, EquationDiagnostic } from '../reference/equations-validate.js';
 import { TableLabelRecord, TableDiagnostic } from '../reference/tables-validate.js';
 import { FigureLabelRecord, FigureDiagnostic } from '../reference/figures-validate.js';
+import { DiagramLabelRecord, DiagramDiagnostic } from '../reference/diagrams-validate.js';
+import { KnowledgeCheckLabelRecord, KnowledgeCheckDiagnostic } from '../reference/knowledge-checks-validate.js';
+import { RawFloatDiagnostic } from '../reference/raw-floats-validate.js';
 import { MathGateDiagnostic } from '../reference/gate-math.js';
+import { ContentSegment } from '../reference/mixed-content.js';
 import { GlyphScopeEntry } from '../reference/gloss.js';
 import { NotationDefinitionRecord, NotationPageBundle, NotationBacklink, NotationDiagnostic, EditorialStatus, NotationGlossEntry } from '../reference/types.js';
-import { CourseConfig } from './course-config.js';
+import { NormalizedLessonExports, CourseConfig } from './course-config.js';
 import { KnowledgeVersionDiagnostic } from './knowledge-version.js';
 import { SidebarGroup } from './lesson-derivation.js';
 import './collections.js';
@@ -51,14 +55,43 @@ import '../reference/keyed-float-validate.js';
  * `lessons[].equations`, and `diagnostics.equations`.
  * v4 (F-tables-figures): `tables`/`figures` (same shape as `equations`, for
  * `<Table>`/`<Figure>`), `lessons[].tables`/`lessons[].figures`, and
- * `diagnostics.tables`/`diagnostics.figures`.
+ * `diagnostics.tables`/`diagnostics.figures`/`diagnostics.diagrams`.
  * v5 (about): `about` (engine identity from `explico`'s `package.json`, the
  * course's reader-facing `about` block, and the knowledge version resolved
  * against `content/CHANGELOG.md`) and `diagnostics.knowledge`.
  * v6 (chapter numbering): `lessons[].chapter` — the lesson's 1-based course
  * ordinal, the chapter in every equation/table/figure number (`(2.1)`).
+ * v7 (part numbering): `lessons[].part` (the sidebar group's 1-based ordinal,
+ * now the number before the dot), `lessons[].chapter` redefined as the
+ * lesson's ordinal *within its part*, and `lessons[].numbering` — the
+ * per-kind offsets that make `n` run continuously across a part.
+ * v8 (assessment math): `assessmentContent` — every assessment item's
+ * `prompt` / `explanation`, pre-split into text/math segments and resolved
+ * against the scope of the lesson that embeds it, so `AssessmentSet.astro`
+ * can render them through the same KaTeX pipeline as lesson body math instead
+ * of showing raw text.
+ * v9 (diagram identity): `diagrams` (the independent `<Diagram>` number and
+ * cross-page lookup), `lessons[].diagrams`, `lessons[].numbering.diagrams`,
+ * and `diagnostics.diagrams`.
+ * v10 (knowledge-check identity): `checks` (part-wide numbering and cross-page
+ * lookup), `lessons[].knowledgeChecks`, `lessons[].numbering.checks`, and
+ * `diagnostics.checks`.
+ * v11 (lesson exports): normalized standalone HTML and print build/UI settings.
+ * v12 (abbreviation hover cards): `manifest.abbreviations` — the
+ * `abbreviations` content collection (N14), flattened to plain
+ * `{key, abbr, expansion, aliases, domain?}` records sorted by key, the way
+ * `manifest.notation.raw` already carries notation frontmatter for
+ * `remarkNotation`. `remarkAbbreviations` reads it to wrap the first
+ * occurrence of a known abbreviation in a lesson's prose with a hover/click
+ * card.
+ * v13 (raw-float diagnostics, additive): `diagnostics.rawFloats` — a raw
+ * Markdown table, a raw HTML `<table>`, or an Explico `<Diagram>` that is
+ * unkeyed or nested outside `<Table>`/`<Figure>` never reaches keyed-float
+ * validation and can never get a stable number or `[[…]]` reference; this
+ * flags it (warning-only — the manifest shape a client already reads is
+ * unchanged).
  */
-declare const MANIFEST_SCHEMA_VERSION = 6;
+declare const MANIFEST_SCHEMA_VERSION = 13;
 declare const MANIFEST_PATH: string;
 interface ManifestCitation {
     readonly id: string;
@@ -108,11 +141,31 @@ interface ManifestLesson {
     /** Docs-loader slug, e.g. `bonds/price-yield-relationship`. */
     readonly slug: string;
     /**
-     * The lesson's 1-based ordinal in the course (merged track order, then any
-     * unranked lessons by slug). It is the chapter in every equation, table, and
-     * figure number on the page — `(2.1)` is the first equation of chapter 2.
+     * The 1-based ordinal of the **part** this lesson sits in — its sidebar
+     * group's position in `courseConfig.parts`. It is the number before the dot
+     * in every equation, table, figure, diagram, and knowledge-check number on
+     * the page: `(2.1)` is the first equation of part 2. See
+     * `docs/authoring/structure.md`.
+     */
+    readonly part: number;
+    /**
+     * The lesson's 1-based ordinal **within its part** (merged track order, then
+     * any unranked lessons by slug) — its chapter number. This orders the
+     * sidebar and the reading path; it does not appear in a float's number.
      */
     readonly chapter: number;
+    /**
+     * How many floats of each kind the earlier lessons of this part already
+     * used. The lesson's own floats continue from here, so a part's sequence
+     * runs unbroken across its chapters instead of restarting on every page.
+     */
+    readonly numbering: {
+        readonly equations: number;
+        readonly tables: number;
+        readonly figures: number;
+        readonly diagrams: number;
+        readonly checks: number;
+    };
     readonly file: string;
     readonly title: string;
     readonly description: string;
@@ -122,6 +175,11 @@ interface ManifestLesson {
     readonly requires: readonly string[];
     readonly assumptions: readonly string[];
     readonly assessments: readonly string[];
+    /** Numbered knowledge checks from `assessments`, in `.checks.yml` order. */
+    readonly knowledgeChecks: readonly {
+        readonly key: string;
+        readonly number: string;
+    }[];
     readonly sources: readonly string[];
     readonly citations: readonly ManifestCitation[];
     /** Competency prerequisite edges this lesson introduces. */
@@ -141,6 +199,11 @@ interface ManifestLesson {
         readonly key: string;
         readonly number: string;
     }[];
+    /** Keyed `<Diagram>` elements in appearance order. */
+    readonly diagrams: readonly {
+        readonly key: string;
+        readonly number: string;
+    }[];
     readonly notation: {
         readonly bindings: readonly {
             readonly key: string;
@@ -181,8 +244,18 @@ interface ManifestAbout {
     readonly disclaimer: string;
     readonly changelogHref?: string;
 }
+/** One assessment item's pre-rendered `prompt` / `explanation` (v8). */
+interface ManifestAssessmentItemContent {
+    readonly lessonId: string;
+    readonly assessmentId: string;
+    readonly itemId: string;
+    readonly promptSegments: readonly ContentSegment[];
+    readonly explanationSegments: readonly ContentSegment[];
+}
 interface Manifest {
     readonly schemaVersion: number;
+    /** Normalized build/UI settings for opt-in per-lesson exports. */
+    readonly lessonExports: NormalizedLessonExports;
     /** Reader-facing identity + versions (the `[?]` About panel). */
     readonly about: ManifestAbout;
     readonly notation: {
@@ -196,6 +269,8 @@ interface Manifest {
     readonly competencies: readonly Record<string, unknown>[];
     readonly sources: readonly Record<string, unknown>[];
     readonly tracks: readonly Record<string, unknown>[];
+    /** Abbreviations table (N14), for `remarkAbbreviations`. Ordered by key. */
+    readonly abbreviations: readonly Record<string, unknown>[];
     readonly sidebar: readonly SidebarGroup[];
     readonly lessons: readonly ManifestLesson[];
     /** Full competency prerequisite graph. */
@@ -216,6 +291,26 @@ interface Manifest {
         readonly labels: readonly FigureLabelRecord[];
         readonly numbersBySlug: Record<string, Record<string, string>>;
     };
+    /** Keyed-float identity for `<Diagram>` — independent of figure numbering. */
+    readonly diagrams: {
+        readonly labels: readonly DiagramLabelRecord[];
+        readonly numbersBySlug: Record<string, Record<string, string>>;
+    };
+    /** Knowledge-check identity, derived from each lesson's `.checks.yml`. */
+    readonly checks: {
+        readonly labels: readonly KnowledgeCheckLabelRecord[];
+        readonly numbersBySlug: Record<string, Record<string, string>>;
+    };
+    /**
+     * Every assessment item's `prompt` / `explanation`, pre-split into
+     * text/math segments (v8). `AssessmentSet.astro` filters this by
+     * `lessonId` + `assessmentId` and renders each `math` segment's `latex`
+     * through `renderNotationMath` before handing the result to
+     * `AssessmentRunner`. An assessment embedded in more than one lesson (via
+     * more than one `checks.yml`) appears once per lesson here, since each
+     * lesson's scope can resolve its glyphs differently.
+     */
+    readonly assessmentContent: readonly ManifestAssessmentItemContent[];
     readonly diagnostics: {
         readonly curriculum: readonly CurriculumIssue[];
         readonly notation: readonly NotationDiagnostic[];
@@ -231,6 +326,16 @@ interface Manifest {
         readonly tables: readonly TableDiagnostic[];
         /** `<Figure>` identity checks (F-tables-figures) — same codes, `fig-` prefixed. */
         readonly figures: readonly FigureDiagnostic[];
+        /** `<Diagram>` identity checks — same codes, `dia-` prefixed. */
+        readonly diagrams: readonly DiagramDiagnostic[];
+        /** Knowledge-check identity and `[[check-…]]` reference checks. */
+        readonly checks: readonly KnowledgeCheckDiagnostic[];
+        /**
+         * A raw Markdown table, a raw HTML `<table>`, or an Explico `<Diagram>`
+         * that is unkeyed or nested outside `<Table>`/`<Figure>` — invisible to
+         * keyed-float validation above. Warnings only.
+         */
+        readonly rawFloats: readonly RawFloatDiagnostic[];
     };
     readonly hashes: {
         /** `sha256` of every content source file, keyed by repo-relative path. */
@@ -259,4 +364,4 @@ declare function readManifestSync(): Manifest;
  */
 declare function loadManifest(courseConfig?: CourseConfig): Promise<Manifest>;
 
-export { MANIFEST_PATH, MANIFEST_SCHEMA_VERSION, type Manifest, type ManifestAbout, type ManifestCitation, type ManifestLesson, type ManifestLessonNotation, type ManifestNotationResolution, type PrereqEdge, compileManifest, loadManifest, readManifestSync, serializeManifest, writeManifest };
+export { MANIFEST_PATH, MANIFEST_SCHEMA_VERSION, type Manifest, type ManifestAbout, type ManifestAssessmentItemContent, type ManifestCitation, type ManifestLesson, type ManifestLessonNotation, type ManifestNotationResolution, type PrereqEdge, compileManifest, loadManifest, readManifestSync, serializeManifest, writeManifest };

package/dist/compiler/manifest.js

@@ -16,6 +16,8 @@ import {
   runConsistencyChecks
 } from "../reference/consistency.js";
 import { validateNotationAlignment } from "../reference/curriculum-alignment.js";
+import { countDisplayEquations } from "../reference/equations.mjs";
+import { countKeyedJsxFloats } from "../reference/keyed-jsx-floats.mjs";
 import {
   validateEquations
 } from "../reference/equations-validate.js";
@@ -26,16 +28,39 @@ import {
   validateFigures
 } from "../reference/figures-validate.js";
 import {
-  gateContentMath
+  validateDiagrams
+} from "../reference/diagrams-validate.js";
+import {
+  validateKnowledgeChecks
+} from "../reference/knowledge-checks-validate.js";
+import {
+  validateRawFloats
+} from "../reference/raw-floats-validate.js";
+import {
+  gateContentMath,
+  pageScope
 } from "../reference/gate-math.js";
+import {
+  gateProseNotation,
+  gateProseNotationInAssessments
+} from "../reference/gate-prose-notation.js";
+import { gateAbbreviations } from "../reference/gate-abbreviations.js";
+import {
+  splitMixedContent
+} from "../reference/mixed-content.js";
 import { loadLintIgnore } from "../reference/lint-ignore.js";
 import { buildNotationRegistry } from "../reference/registry.js";
 import { formulaGlyphScope } from "../reference/gloss.js";
 import { resolveReferenceId } from "../reference/references.js";
+import {
+  coursePartsOf,
+  normalizeLessonExports
+} from "./course-config.js";
 import {
   resolveKnowledgeVersion
 } from "./knowledge-version.js";
 import {
+  loadAbbreviationRegistryInput,
   loadCurriculumCatalog,
   loadNotationDefinitions,
   loadNotationRegistryInput,
@@ -48,7 +73,7 @@ import {
   isLessonSlug,
   lessonIdFromSlug
 } from "./lesson-derivation.js";
-const MANIFEST_SCHEMA_VERSION = 6;
+const MANIFEST_SCHEMA_VERSION = 13;
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
 const MANIFEST_PATH = join(REPOSITORY_ROOT, "build", "manifest.json");
@@ -181,9 +206,10 @@ async function compileManifest(courseConfig) {
       "course.config.ts is missing a complete `about` block (required since explico 0.3.0): `about: { version, authors: [{ name }], disclaimer, materialName?, summary?, changelogHref? }`. See docs/authoring/migrating.md (\xA7 0.2.x \u2192 0.3.0) in the installed package."
     );
   }
-  const [catalog, notationInput] = await Promise.all([
+  const [catalog, notationInput, abbreviationsInput] = await Promise.all([
     loadCurriculumCatalog(),
-    loadNotationRegistryInput()
+    loadNotationRegistryInput(),
+    loadAbbreviationRegistryInput()
   ]);
   const registry = buildNotationRegistry(notationInput);
   const cardsByKey = new Map(
@@ -199,16 +225,53 @@ async function compileManifest(courseConfig) {
   const bundlesByLesson = new Map(
     registry.bundles.map((bundle) => [bundle.lessonId, bundle])
   );
+  const assessmentsInput = catalog.assessments;
   const curriculumIssues = validateCurriculum(catalog);
   const alignmentIssues = validateNotationAlignment(registry, catalog);
-  const mathIssues = gateContentMath({
-    notationInput,
-    assessments: catalog.assessments,
-    lessonAssessments: catalog.lessons.map((lesson) => ({
-      lessonId: lesson.id,
-      assessmentIds: lesson.assessments
-    }))
-  });
+  const mathIssues = [
+    ...gateContentMath({
+      notationInput,
+      assessments: assessmentsInput,
+      lessonAssessments: catalog.lessons.map((lesson) => ({
+        lessonId: lesson.id,
+        assessmentIds: lesson.assessments
+      }))
+    }),
+    ...gateProseNotation(notationInput.lessons),
+    ...gateProseNotationInAssessments(assessmentsInput),
+    ...gateAbbreviations({
+      notationInput,
+      abbreviations: abbreviationsInput,
+      courseAbbreviations: courseConfig.abbreviations
+    })
+  ];
+  const notationLessonById = new Map(
+    notationInput.lessons.map((lesson) => [lesson.lessonId, lesson])
+  );
+  const assessmentInputById = new Map(
+    assessmentsInput.map((assessment) => [assessment.id, assessment])
+  );
+  const assessmentContent = [];
+  for (const lesson of catalog.lessons) {
+    if (lesson.assessments.length === 0) continue;
+    const lessonInput = notationLessonById.get(lesson.id);
+    if (!lessonInput) continue;
+    const scope = pageScope(lessonInput, cardsByKey);
+    for (const assessmentId of lesson.assessments) {
+      const assessment = assessmentInputById.get(assessmentId);
+      if (!assessment?.items) continue;
+      for (const item of assessment.items) {
+        if (!item.id) continue;
+        assessmentContent.push({
+          lessonId: lesson.id,
+          assessmentId,
+          itemId: item.id,
+          promptSegments: splitMixedContent(item.prompt ?? "", scope),
+          explanationSegments: splitMixedContent(item.explanation ?? "", scope)
+        });
+      }
+    }
+  }
   const prerequisitesById = new Map(
     catalog.competencies.map((competency) => [
       competency.id,
@@ -231,44 +294,114 @@ async function compileManifest(courseConfig) {
   const sidebar = buildSidebar(
     catalog.tracks.map((track) => ({ id: track.id, lessons: track.lessons })),
     lessonSlugs,
-    courseConfig.sections
+    coursePartsOf(courseConfig)
+  );
+  const bodyByLessonId = new Map(
+    notationInput.lessons.map((lesson) => [lesson.lessonId, lesson.body])
   );
-  const chapterByLessonId = /* @__PURE__ */ new Map();
-  let chapterCursor = 0;
+  const placementByLessonId = /* @__PURE__ */ new Map();
+  let partCursor = 0;
   for (const group of sidebar) {
-    for (const item of group.items) {
-      if (typeof item !== "string") continue;
-      chapterByLessonId.set(lessonIdFromSlug(item), ++chapterCursor);
+    const lessonIds = group.items.filter((item) => typeof item === "string").map(lessonIdFromSlug);
+    if (lessonIds.length === 0) continue;
+    partCursor += 1;
+    const used = {
+      equations: 0,
+      tables: 0,
+      figures: 0,
+      diagrams: 0,
+      checks: 0
+    };
+    let chapterCursor = 0;
+    for (const lessonId of lessonIds) {
+      const body = bodyByLessonId.get(lessonId) ?? "";
+      placementByLessonId.set(lessonId, {
+        part: partCursor,
+        chapter: ++chapterCursor,
+        numbering: { ...used }
+      });
+      used.equations += countDisplayEquations(body);
+      used.tables += countKeyedJsxFloats(body, { tagName: "Table" });
+      used.figures += countKeyedJsxFloats(body, { tagName: "Figure" });
+      used.diagrams += countKeyedJsxFloats(body, { tagName: "Diagram" });
+      used.checks += lessonMetaById.get(lessonId)?.assessments.length ?? 0;
     }
   }
-  const keyedFloatLessonInputs = notationInput.lessons.map((lesson) => ({
-    lessonId: lesson.lessonId,
-    slug: lesson.lessonId.replace(/\./g, "/"),
-    file: lesson.source.file,
-    body: lesson.body,
-    chapter: chapterByLessonId.get(lesson.lessonId)
-  }));
-  const equationValidation = validateEquations(keyedFloatLessonInputs);
+  const floatInputs = (kind) => notationInput.lessons.map((lesson) => {
+    const placement = placementByLessonId.get(lesson.lessonId);
+    return {
+      lessonId: lesson.lessonId,
+      slug: lesson.lessonId.replace(/\./g, "/"),
+      file: lesson.source.file,
+      body: lesson.body,
+      ...placement ? {
+        numbering: {
+          prefix: placement.part,
+          offset: placement.numbering[kind]
+        }
+      } : {}
+    };
+  });
+  const equationValidation = validateEquations(floatInputs("equations"));
   const equationsBySlug = new Map(
     Object.entries(equationValidation.numbersBySlug).map(([slug, table]) => [
       slug,
       Object.entries(table).map(([key, number]) => ({ key, number }))
     ])
   );
-  const tableValidation = validateTables(keyedFloatLessonInputs);
+  const tableValidation = validateTables(floatInputs("tables"));
   const tablesBySlug = new Map(
     Object.entries(tableValidation.numbersBySlug).map(([slug, table]) => [
       slug,
       Object.entries(table).map(([key, number]) => ({ key, number }))
     ])
   );
-  const figureValidation = validateFigures(keyedFloatLessonInputs);
+  const figureValidation = validateFigures(floatInputs("figures"));
   const figuresBySlug = new Map(
     Object.entries(figureValidation.numbersBySlug).map(([slug, table]) => [
       slug,
       Object.entries(table).map(([key, number]) => ({ key, number }))
     ])
   );
+  const diagramValidation = validateDiagrams(floatInputs("diagrams"));
+  const diagramsBySlug = new Map(
+    Object.entries(diagramValidation.numbersBySlug).map(([slug, table]) => [
+      slug,
+      Object.entries(table).map(([key, number]) => ({ key, number }))
+    ])
+  );
+  const checkValidation = validateKnowledgeChecks(
+    notationInput.lessons.map((lesson) => {
+      const placement = placementByLessonId.get(lesson.lessonId);
+      return {
+        lessonId: lesson.lessonId,
+        slug: lesson.lessonId.replace(/\./g, "/"),
+        file: lesson.source.file,
+        body: lesson.body,
+        assessmentIds: lessonMetaById.get(lesson.lessonId)?.assessments ?? [],
+        ...placement ? {
+          numbering: {
+            prefix: placement.part,
+            offset: placement.numbering.checks
+          }
+        } : {}
+      };
+    })
+  );
+  const checksBySlug = new Map(
+    Object.entries(checkValidation.numbersBySlug).map(([slug, table]) => [
+      slug,
+      Object.entries(table).map(([key, number]) => ({ key, number }))
+    ])
+  );
+  const rawFloatDiagnostics = validateRawFloats(
+    notationInput.lessons.map((lesson) => ({
+      lessonId: lesson.lessonId,
+      slug: lesson.lessonId.replace(/\./g, "/"),
+      file: lesson.source.file,
+      body: lesson.body
+    }))
+  );
   const lessons = [];
   for (const notationLesson of notationInput.lessons) {
     const id = notationLesson.lessonId;
@@ -282,10 +415,18 @@ async function compileManifest(courseConfig) {
     lessons.push({
       id,
       slug: id.replace(/\./g, "/"),
-      // 0 = the lesson is not placed in any configured section; a curriculum
+      // 0 = the lesson is not placed in any configured part; a curriculum
       // diagnostic covers that separately, and both numbering paths then fall
       // back to the legacy `##`-section scheme.
-      chapter: chapterByLessonId.get(id) ?? 0,
+      part: placementByLessonId.get(id)?.part ?? 0,
+      chapter: placementByLessonId.get(id)?.chapter ?? 0,
+      numbering: placementByLessonId.get(id)?.numbering ?? {
+        equations: 0,
+        tables: 0,
+        figures: 0,
+        diagrams: 0,
+        checks: 0
+      },
       file: notationLesson.source.file,
       title: frontmatter.title,
       description: frontmatter.description,
@@ -294,11 +435,13 @@ async function compileManifest(courseConfig) {
       requires: [...meta.requires],
       assumptions: [...meta.assumptions],
       assessments: [...meta.assessments],
+      knowledgeChecks: checksBySlug.get(id.replace(/\./g, "/")) ?? [],
       sources: deriveSources(notationLesson.body),
       citations: lessonCitations(notationLesson.body),
       equations: equationsBySlug.get(id.replace(/\./g, "/")) ?? [],
       tables: tablesBySlug.get(id.replace(/\./g, "/")) ?? [],
       figures: figuresBySlug.get(id.replace(/\./g, "/")) ?? [],
+      diagrams: diagramsBySlug.get(id.replace(/\./g, "/")) ?? [],
       prereqEdges: sortEdges(
         teaches.flatMap(
           (to) => (prerequisitesById.get(to) ?? []).filter((from) => !teaches.includes(from)).map((from) => ({ from, to }))
@@ -324,7 +467,8 @@ async function compileManifest(courseConfig) {
     catalog,
     lintIgnore: loadLintIgnore(),
     conventions: courseConfig.conventions,
-    ...courseConfig.operators === void 0 ? {} : { operators: courseConfig.operators }
+    ...courseConfig.operators === void 0 ? {} : { operators: courseConfig.operators },
+    ...courseConfig.romanLabels === void 0 ? {} : { romanLabels: courseConfig.romanLabels }
   });
   const rawNotation = [...loadNotationDefinitions()].sort(
     (a, b) => String(a.key).localeCompare(String(b.key))
@@ -332,6 +476,13 @@ async function compileManifest(courseConfig) {
   const competencies = catalog.competencies.map((entry) => ({ ...entry })).sort(byId);
   const sources = [...loadSourceRecords()].sort(byId);
   const tracks = catalog.tracks.map((entry) => ({ ...entry })).sort(byId);
+  const abbreviations = abbreviationsInput.map((entry) => ({
+    key: entry.key,
+    abbr: entry.abbr,
+    expansion: entry.expansion,
+    aliases: entry.aliases,
+    ...entry.domain === void 0 ? {} : { domain: entry.domain }
+  })).sort((a, b) => a.key.localeCompare(b.key));
   const hashes = contentHashes();
   const knowledgeChangelogPath = join(CONTENT_ROOT, "CHANGELOG.md");
   const knowledge = resolveKnowledgeVersion({
@@ -365,6 +516,7 @@ async function compileManifest(courseConfig) {
   };
   return {
     schemaVersion: MANIFEST_SCHEMA_VERSION,
+    lessonExports: normalizeLessonExports(courseConfig),
     about,
     notation: {
       definitions: registry.definitions,
@@ -376,6 +528,7 @@ async function compileManifest(courseConfig) {
     competencies,
     sources,
     tracks,
+    abbreviations,
     sidebar,
     lessons,
     prereqEdges,
@@ -391,6 +544,15 @@ async function compileManifest(courseConfig) {
       labels: figureValidation.labels,
       numbersBySlug: figureValidation.numbersBySlug
     },
+    diagrams: {
+      labels: diagramValidation.labels,
+      numbersBySlug: diagramValidation.numbersBySlug
+    },
+    checks: {
+      labels: checkValidation.labels,
+      numbersBySlug: checkValidation.numbersBySlug
+    },
+    assessmentContent,
     diagnostics: {
       curriculum: curriculumIssues,
       notation: registry.diagnostics,
@@ -400,7 +562,10 @@ async function compileManifest(courseConfig) {
       equations: equationValidation.diagnostics,
       tables: tableValidation.diagnostics,
       figures: figureValidation.diagnostics,
-      knowledge: knowledge.diagnostics
+      diagrams: diagramValidation.diagnostics,
+      checks: checkValidation.diagnostics,
+      knowledge: knowledge.diagnostics,
+      rawFloats: rawFloatDiagnostics
     },
     hashes
   };
@@ -437,15 +602,15 @@ function readManifestSync() {
   return JSON.parse(readFileSync(MANIFEST_PATH, "utf8"));
 }
 async function loadManifest(courseConfig) {
-  if (existsSync(MANIFEST_PATH)) return readManifestSync();
-  if (!courseConfig) {
-    throw new Error(
-      `${relative(REPOSITORY_ROOT, MANIFEST_PATH)} not found. Run \`pnpm validate:content\` first.`
-    );
+  if (courseConfig) {
+    const manifest = await compileManifest(courseConfig);
+    writeManifest(manifest);
+    return manifest;
   }
-  const manifest = await compileManifest(courseConfig);
-  writeManifest(manifest);
-  return manifest;
+  if (existsSync(MANIFEST_PATH)) return readManifestSync();
+  throw new Error(
+    `${relative(REPOSITORY_ROOT, MANIFEST_PATH)} not found. Run \`pnpm validate:content\` first.`
+  );
 }
 export {
   MANIFEST_PATH,

package/dist/compiler/resolution-report.d.ts

@@ -9,7 +9,11 @@ import '../reference/equations-validate.js';
 import '../reference/tables-validate.js';
 import '../reference/keyed-float-validate.js';
 import '../reference/figures-validate.js';
+import '../reference/diagrams-validate.js';
+import '../reference/knowledge-checks-validate.js';
+import '../reference/raw-floats-validate.js';
 import '../reference/gate-math.js';
+import '../reference/mixed-content.js';
 import '../reference/gloss.js';
 import './knowledge-version.js';
 import './lesson-derivation.js';

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

@@ -0,0 +1,30 @@
+/**
+ * The abbreviations a course treats as common, given its `course.config.ts`
+ * `abbreviations` block: the shipped baseline, plus `allow`, minus `deny`.
+ *
+ * @param {{ allow?: readonly string[], deny?: readonly string[] } | undefined} abbreviations
+ * @returns {Set<string>}
+ */
+export function effectiveAbbreviationAllowlist(abbreviations: {
+    allow?: readonly string[];
+    deny?: readonly string[];
+} | undefined): Set<string>;
+/** True when `token` needs no abbreviations-table entry for this course. */
+export function isBaseAbbreviation(token: any, abbreviations: any): boolean;
+/**
+ * The base abbreviation baseline: acronyms and dotted abbreviations every
+ * reader is assumed to know, so a lesson never has to introduce them with an
+ * abbreviations-table entry. The `\operatorname{…}` / `\mathrm{…}` twins are
+ * `base-operators.mjs` (rule N8) / `base-roman-labels.mjs` (rule N10); this is
+ * the plain-prose equivalent for rule N14.
+ *
+ * Kept intentionally small, same rationale as `BASE_ROMAN_LABELS`: a
+ * course-specific acronym (`OLS`, `SSR`, `MSE`) is exactly the thing a reader
+ * benefits from having spelled out, so it belongs in the course's own
+ * `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`.
+ */
+export const BASE_ABBREVIATIONS: Readonly<Set<string>>;