explico 0.3.0 → 0.5.0

package/src/compiler/lesson-derivation.ts

@@ -156,7 +156,7 @@ export type SidebarGroup =
 export function buildSidebar(
   tracks: readonly TrackLike[],
   lessonSlugs: readonly string[],
-  sections: readonly SidebarSection[],
+  parts: readonly SidebarSection[],
 ): SidebarGroup[] {
   const rank = new Map(
     mergeTrackOrder(tracks).map((lessonId, index) => [lessonId, index]),
@@ -164,7 +164,7 @@ export function buildSidebar(
   const positionOf = (slug: string) =>
     rank.get(lessonIdFromSlug(slug)) ?? Number.POSITIVE_INFINITY;
 
-  const groups: SidebarGroup[] = sections.map(({ dir, label }) => ({
+  const groups: SidebarGroup[] = parts.map(({ dir, label }) => ({
     label,
     items: lessonSlugs
       .filter((slug) => slug.startsWith(`${dir}/`))

package/src/compiler/manifest.ts

@@ -47,6 +47,8 @@ import {
   type ConsistencyDiagnostic,
 } from '../reference/consistency';
 import { validateNotationAlignment } from '../reference/curriculum-alignment';
+import { countDisplayEquations } from '../reference/equations.mjs';
+import { countKeyedJsxFloats } from '../reference/keyed-jsx-floats.mjs';
 import {
   validateEquations,
   type EquationDiagnostic,
@@ -62,10 +64,34 @@ import {
   type FigureDiagnostic,
   type FigureLabelRecord,
 } from '../reference/figures-validate';
+import {
+  validateDiagrams,
+  type DiagramDiagnostic,
+  type DiagramLabelRecord,
+} from '../reference/diagrams-validate';
+import {
+  validateKnowledgeChecks,
+  type KnowledgeCheckDiagnostic,
+  type KnowledgeCheckLabelRecord,
+} from '../reference/knowledge-checks-validate';
+import {
+  validateRawFloats,
+  type RawFloatDiagnostic,
+} from '../reference/raw-floats-validate';
 import {
   gateContentMath,
+  pageScope,
   type MathGateDiagnostic,
 } from '../reference/gate-math';
+import {
+  gateProseNotation,
+  gateProseNotationInAssessments,
+} from '../reference/gate-prose-notation';
+import { gateAbbreviations } from '../reference/gate-abbreviations';
+import {
+  splitMixedContent,
+  type ContentSegment,
+} from '../reference/mixed-content';
 import { loadLintIgnore } from '../reference/lint-ignore';
 import { buildNotationRegistry } from '../reference/registry';
 import { formulaGlyphScope } from '../reference/gloss';
@@ -80,12 +106,18 @@ import type {
   NotationLessonInput,
   NotationPageBundle,
 } from '../reference/types';
-import type { CourseConfig } from './course-config';
+import {
+  coursePartsOf,
+  normalizeLessonExports,
+  type CourseConfig,
+  type NormalizedLessonExports,
+} from './course-config';
 import {
   resolveKnowledgeVersion,
   type KnowledgeVersionDiagnostic,
 } from './knowledge-version';
 import {
+  loadAbbreviationRegistryInput,
   loadCurriculumCatalog,
   loadNotationDefinitions,
   loadNotationRegistryInput,
@@ -110,14 +142,43 @@ import {
  * `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).
  */
-export const MANIFEST_SCHEMA_VERSION = 6;
+export const MANIFEST_SCHEMA_VERSION = 13;
 
 const REPOSITORY_ROOT = process.cwd();
 // Content is the top-level `content/` folder; the build output is `build/`
@@ -206,11 +267,31 @@ export 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;
@@ -220,6 +301,11 @@ export 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. */
@@ -239,6 +325,11 @@ export 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;
@@ -278,8 +369,19 @@ export interface ManifestAbout {
   readonly changelogHref?: string;
 }
 
+/** One assessment item's pre-rendered `prompt` / `explanation` (v8). */
+export interface ManifestAssessmentItemContent {
+  readonly lessonId: string;
+  readonly assessmentId: string;
+  readonly itemId: string;
+  readonly promptSegments: readonly ContentSegment[];
+  readonly explanationSegments: readonly ContentSegment[];
+}
+
 export 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: {
@@ -293,6 +395,8 @@ export 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. */
@@ -313,6 +417,26 @@ export 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[];
@@ -328,6 +452,16 @@ export 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. */
@@ -523,9 +657,10 @@ export async function compileManifest(
     );
   }
 
-  const [catalog, notationInput] = await Promise.all([
+  const [catalog, notationInput, abbreviationsInput] = await Promise.all([
     loadCurriculumCatalog(),
     loadNotationRegistryInput(),
+    loadAbbreviationRegistryInput(),
   ]);
 
   const registry = buildNotationRegistry(notationInput);
@@ -545,19 +680,65 @@ export async function compileManifest(
     registry.bundles.map((bundle) => [bundle.lessonId, bundle]),
   );
 
+  const assessmentsInput = catalog.assessments as unknown as {
+    id: string;
+    items?: { id?: string; prompt?: string; explanation?: string }[];
+  }[];
+
   const curriculumIssues = validateCurriculum(catalog);
   const alignmentIssues = validateNotationAlignment(registry, catalog);
-  const mathIssues = gateContentMath({
-    notationInput,
-    assessments: catalog.assessments as unknown as {
-      id: string;
-      items?: { id?: string; prompt?: string; explanation?: string }[];
-    }[],
-    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,
+    }),
+  ];
+
+  // Pre-render every assessment `prompt` / `explanation` into text/math
+  // segments, resolved against the scope of whichever lesson embeds it —
+  // same relationship, same `pageScope`, as the `gateContentMath` assessment
+  // check above, so a symbol that passes the gate is exactly the symbol
+  // `AssessmentSet.astro` renders. An assessment shared by two lessons is
+  // rendered once per (lesson, assessment) pair, since the two lessons can
+  // have different scopes and therefore different resolved LaTeX.
+  const notationLessonById = new Map(
+    notationInput.lessons.map((lesson) => [lesson.lessonId, lesson]),
+  );
+  const assessmentInputById = new Map(
+    assessmentsInput.map((assessment) => [assessment.id, assessment]),
+  );
+  const assessmentContent: ManifestAssessmentItemContent[] = [];
+  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) => [
@@ -586,51 +767,148 @@ export async function compileManifest(
   const sidebar = buildSidebar(
     catalog.tracks.map((track) => ({ id: track.id, lessons: track.lessons })),
     lessonSlugs,
-    courseConfig.sections,
+    coursePartsOf(courseConfig),
   );
 
-  // A lesson's chapter is its position when the sidebar is read top to bottom
-  // (sections in config order, lessons within a section by merged track order
-  // then slug). It prefixes every equation / table / figure number on the page
-  // (`(2.1)` = first equation of chapter 2). Derived from `sidebar` so there is
-  // one lesson-ordering source, not two.
-  const chapterByLessonId = new Map<string, number>();
-  let chapterCursor = 0;
+  // Part and chapter, read straight off the sidebar so there is one
+  // lesson-ordering source and not two: a part is a sidebar group (parts in
+  // config order), a chapter is a lesson's position inside its part (merged
+  // track order, then slug). The part is what prefixes every numbered item —
+  // `(2.1)` is the first item of one independent kind in part 2 — while `n`
+  // continues across the part's chapters rather than restarting on each page,
+  // so every lesson also needs the running count that precedes it.
+  // See `docs/authoring/structure.md`.
+  const bodyByLessonId = new Map(
+    notationInput.lessons.map((lesson) => [lesson.lessonId, lesson.body]),
+  );
+  const placementByLessonId = new Map<
+    string,
+    {
+      part: number;
+      chapter: number;
+      numbering: {
+        equations: number;
+        tables: number;
+        figures: number;
+        diagrams: number;
+        checks: number;
+      };
+    }
+  >();
+  let partCursor = 0;
   for (const group of sidebar) {
-    for (const item of group.items) {
-      if (typeof item !== 'string') continue; // the static Reference group
-      chapterByLessonId.set(lessonIdFromSlug(item), ++chapterCursor);
+    const lessonIds = group.items
+      .filter((item): item is string => typeof item === 'string')
+      .map(lessonIdFromSlug);
+    if (lessonIds.length === 0) continue; // the static Reference group
+    partCursor += 1;
+    // Running totals for this part, advanced one chapter at a time.
+    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: 'equations' | 'tables' | 'figures' | 'diagrams',
+  ) =>
+    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: ManifestLesson[] = [];
   for (const notationLesson of notationInput.lessons) {
@@ -645,10 +923,18 @@ export async function compileManifest(
     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,
@@ -657,11 +943,13 @@ export async function compileManifest(
       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) ?? [])
@@ -693,6 +981,9 @@ export async function compileManifest(
     ...(courseConfig.operators === undefined
       ? {}
       : { operators: courseConfig.operators }),
+    ...(courseConfig.romanLabels === undefined
+      ? {}
+      : { romanLabels: courseConfig.romanLabels }),
   });
 
   const rawNotation = [...loadNotationDefinitions()].sort((a, b) =>
@@ -703,6 +994,15 @@ export async function compileManifest(
     .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 === undefined ? {} : { domain: entry.domain }),
+    }))
+    .sort((a, b) => a.key.localeCompare(b.key));
 
   const hashes = contentHashes();
 
@@ -751,6 +1051,7 @@ export async function compileManifest(
 
   return {
     schemaVersion: MANIFEST_SCHEMA_VERSION,
+    lessonExports: normalizeLessonExports(courseConfig),
     about,
     notation: {
       definitions: registry.definitions,
@@ -762,6 +1063,7 @@ export async function compileManifest(
     competencies,
     sources,
     tracks,
+    abbreviations,
     sidebar,
     lessons,
     prereqEdges,
@@ -777,6 +1079,15 @@ export async function compileManifest(
       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,
@@ -786,7 +1097,10 @@ export async function compileManifest(
       equations: equationValidation.diagnostics,
       tables: tableValidation.diagnostics,
       figures: figureValidation.diagnostics,
+      diagrams: diagramValidation.diagnostics,
+      checks: checkValidation.diagnostics,
       knowledge: knowledge.diagnostics,
+      rawFloats: rawFloatDiagnostics,
     },
     hashes,
   };
@@ -842,13 +1156,17 @@ export function readManifestSync(): Manifest {
 export async function loadManifest(
   courseConfig?: CourseConfig,
 ): Promise<Manifest> {
-  if (existsSync(MANIFEST_PATH)) return readManifestSync();
-  if (!courseConfig) {
-    throw new Error(
-      `${relative(REPOSITORY_ROOT, MANIFEST_PATH)} not found. Run \`pnpm validate:content\` first.`,
-    );
+  // A caller that has the course config is an authoring/build entry point. It
+  // must compile the current content tree even when a persisted manifest is
+  // present: using that file here can split the page in two, with remark
+  // seeing current frontmatter while Astro components render stale cards.
+  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.`,
+  );
 }