explico 0.11.1 → 0.13.0

package/src/compiler/manifest.ts

@@ -84,11 +84,18 @@ import {
   validateRawFloats,
   type RawFloatDiagnostic,
 } from '../reference/raw-floats-validate';
+import {
+  validateLabKatexImports,
+  type LabKatexDiagnostic,
+} from '../reference/lab-katex-validate';
 import {
   gateContentMath,
   pageScope,
+  scopeEntry,
   type MathGateDiagnostic,
 } from '../reference/gate-math';
+import { gateIndices, type DerivedUse } from '../reference/gate-indices';
+import { derivedNotationEntries } from '../reference/derived-entries';
 import {
   gateProseNotation,
   gateProseNotationInAssessments,
@@ -102,12 +109,18 @@ import { gateCourseRules } from '../reference/gate-course-rules';
 import { gateHeadingLength } from '../reference/gate-heading-length';
 import { gateHeadingStructure } from '../reference/gate-heading-structure';
 import { gatePartPages } from '../reference/gate-part-pages';
+import { gateNonChapterPages } from '../reference/gate-non-chapter-pages';
+import { findRetiredKeys, findUnsupportedKeys } from '../reference/gate-retired-keys';
+import { findMarkupInProps } from '../reference/gate-prop-text';
+import { gateMdxExpressions } from '../reference/gate-mdx-expression';
+import { CITATION_BRACKET, bracketCitations, withoutLinkCitations } from '../reference/citation-format.mjs';
+import { validateContentSchemas } from './content-schema';
 import {
   scanSectionHeadings,
   scanTitledBlocks,
 } from '../reference/sections.mjs';
 import { knowledgeCheckAnchorId } from '../reference/knowledge-checks.mjs';
-import { validateSectionRefs } from '../reference/sections-validate';
+import { validateHeadingAnchors, validateSectionRefs } from '../reference/sections-validate';
 import {
   splitMixedContent,
   type ContentSegment,
@@ -119,7 +132,6 @@ import type { GlyphScopeEntry } from '../reference/gloss';
 import { resolveReferenceId } from '../reference/references';
 import type { NotationGlossEntry } from '../reference/types';
 import type {
-  EditorialStatus,
   NotationBacklink,
   NotationDefinitionRecord,
   NotationDiagnostic,
@@ -129,11 +141,13 @@ import type {
 import {
   coursePartsOf,
   normalizeBlockLabels,
+  normalizeCards,
   normalizeLessonExports,
   normalizeDisclosure,
   normalizeNumbering,
   type BlockLabels,
   type CourseConfig,
+  type NormalizedCards,
   type NormalizedLessonExports,
   type NormalizedDisclosure,
   type NormalizedNumbering,
@@ -158,9 +172,11 @@ import {
 } from './knowledge-version';
 import {
   loadAbbreviationRegistryInput,
+  loadContentRecords,
   loadCurriculumCatalog,
   loadNotationDefinitions,
   loadNotationRegistryInput,
+  loadNonChapterPages,
   loadNotationSpecs,
   loadPartOverviews,
   loadSourceRecords,
@@ -290,8 +306,48 @@ import {
  * state of a `<Fold>`; `disclosure.figures` now says whether a lab's tools
  * start open; `diagnostics.folds` holds `fold-unnamed`
  * (docs/plans/figures-and-short-captions.md, Parts 1–2).
+ *
+ * v25 (cards on non-chapter pages, rule S10): `pages` — every docs page that
+ * is not a chapter (the landing page, a part's overview page, …) with its
+ * `id`, `slug`, `file` and a `notation` bundle of the lesson shape, so the
+ * footer renders the cards its `[[key]]` terms and math open.
+ * `notation.bundles` and `notation.backlinks` now carry those pages' ids too.
+ *
+ * v26 (carried cards, additive): `cards` — the course's `cards` settings with
+ * the engine defaults applied: whether "Carry cards" starts on (rule K1).
+ *
+ * v27 (LaTeX export): `lessonExports.latex` and `lessonExports.latexPaper`;
+ * every `assessmentContent` item carries its `type`, a choice item's
+ * `options` (plain-text labels) and `correctOptionId`, and a
+ * numeric item's `answer`, so an answer key can be printed without re-reading
+ * `content/assessments/`.
+ *
+ * v28 (Markdown export): `lessonExports.markdown`.
+ *
+ * v29 (no editorial status): the draft / in-review / reviewed flag is gone —
+ * `lessons[].status`, `editorialStatus` on the notation definitions of
+ * `lessons[]` and `pages[]`, and `status` on `notation.definitions[]` and
+ * `notation.bundles[]`. `diagnostics.curriculum` carries `retired-key`, with
+ * `file` and `line`, for a content file that still sets the key, and the
+ * lesson-assumptions check reports `missing-assumptions`, not `review-state`.
+ *
+ * v30 (headings with math, additive): `lessons[].headings[].text` is what a
+ * reader sees — inline math as it reads (`$\explain{k}{R}$` is `R`, not its
+ * LaTeX) and a `[[key]]` term as its label — and `math: true` marks a heading
+ * with inline math. A heading's `slug` is unchanged. Each choice option of
+ * `assessmentContent` carries `labelSegments`, its label split into text and
+ * math like `promptSegments`, so a label's math renders.
+ *
+ * v31 (indexed symbols, rule N23): the `notation` bundle of `lessons[]` and
+ * `pages[]` gains `derived` — the derived cards its body math uses, each
+ * composed from a base entry and an index entry (`\mathbf{v}_0` from
+ * `\mathbf{v}` and `{}_0`), keyed `<base>.sub.<index>`. A notation
+ * definition carries `reads`, `range`, `fixedIndex` and an index entry's
+ * `formulaTemplate` when its entry sets them, and a bundle definition its
+ * `range`. `diagnostics.math` carries `index-explained`, `index-swallowed`,
+ * `index-range` and `derived-key-taken`.
  */
-export const MANIFEST_SCHEMA_VERSION = 24;
+export const MANIFEST_SCHEMA_VERSION = 31;
 
 const REPOSITORY_ROOT = process.cwd();
 // Content is the top-level `content/` folder; the build output is `build/`
@@ -361,10 +417,11 @@ export interface ManifestLessonNotation {
   readonly notation: string;
   readonly label: string;
   readonly summary: string;
-  readonly editorialStatus: EditorialStatus;
   readonly seeAlso: readonly string[];
   readonly units?: string;
   readonly formula?: string;
+  /** Rule N23: the set a running index letter runs over, shown on its card (v31). */
+  readonly range?: string;
   /** Symbols the formula names that have no card of their own (D15). */
   readonly glosses: readonly NotationGlossEntry[];
   /**
@@ -375,6 +432,27 @@ export interface ManifestLessonNotation {
   readonly formulaScope: readonly GlyphScopeEntry[];
 }
 
+/**
+ * A derived card (rule N23, v31): the card of a symbol with a subscript that
+ * an index entry explains, composed from the `base` entry and the `index`
+ * entry by `derived-notation.mjs`. Its title and summary are about the
+ * indexed symbol; its formula names the base, whose card is one level deeper.
+ * It is listed nowhere — not in the Page notation panel, the glossary or an
+ * export's notation section — and opens only from the symbol.
+ */
+export interface ManifestDerivedNotation {
+  readonly key: string;
+  readonly base: string;
+  readonly index: string;
+  readonly notation: string;
+  readonly label: string;
+  readonly summary: string;
+  readonly units?: string;
+  readonly formula?: string;
+  readonly glosses: readonly NotationGlossEntry[];
+  readonly formulaScope: readonly GlyphScopeEntry[];
+}
+
 /**
  * One keyed float of a lesson (v21): its key and number, and its caption pair
  * — `short` (an equation's `\caption{…}`, or the `short` prop) and, for a
@@ -444,16 +522,18 @@ export interface ManifestLesson {
    */
   readonly headings: readonly {
     readonly slug: string;
+    /** What a reader sees: math as it reads, a `[[key]]` term as its label (v30). */
     readonly text: string;
     readonly level: number;
     readonly number?: string;
+    /** The heading has inline math (v30). */
+    readonly math?: true;
   }[];
   readonly file: string;
   readonly title: string;
   readonly description: string;
   /** Authored reader-facing estimate; `40` and `[30, 40]` both land here. */
   readonly studyMinutes?: { readonly min: number; readonly max: number };
-  readonly status: EditorialStatus;
   /** Ordered — the curriculum contract. */
   readonly teaches: readonly string[];
   readonly requires: readonly string[];
@@ -497,11 +577,27 @@ export interface ManifestLesson {
     }[];
     readonly definitionIds: readonly string[];
     readonly definitions: readonly ManifestLessonNotation[];
+    /** The derived cards (rule N23) the page's body math uses (v31). */
+    readonly derived: readonly ManifestDerivedNotation[];
     /** Every `[[key]]` / `\explain{key}` occurrence, resolved and located. */
     readonly resolution: readonly ManifestNotationResolution[];
   };
 }
 
+/**
+ * A docs page that is not a chapter (v25, rule S10) — the landing page, a
+ * part's overview page, any page outside a part directory. It numbers
+ * nothing, so it carries only what its cards need: the notation bundle its
+ * `[[key]]` terms and math reach, shared entries only.
+ */
+export interface ManifestPage {
+  /** `index`, `motion.index`, `glossary` — `lessonIdFromSlug` of the slug; never a lesson id. */
+  readonly id: string;
+  readonly slug: string;
+  readonly file: string;
+  readonly notation: ManifestLesson['notation'];
+}
+
 /** The reader-facing "about this material" bundle — the `[?]` panel's data. */
 export interface ManifestAbout {
   /** `explico`'s own identity, from its `package.json` (the version's golden source). */
@@ -536,6 +632,22 @@ export interface ManifestAssessmentItemContent {
   readonly itemId: string;
   readonly promptSegments: readonly ContentSegment[];
   readonly explanationSegments: readonly ContentSegment[];
+  /** What kind of answer the item takes (v27). */
+  readonly type: 'single-choice' | 'numeric';
+  /**
+   * A choice item's options in authored order: the label as authored, and
+   * split into text and math like the prompt (`labelSegments`, v30), so a
+   * label's math renders.
+   */
+  readonly options?: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly labelSegments: readonly ContentSegment[];
+  }[];
+  /** A choice item's correct option. */
+  readonly correctOptionId?: string;
+  /** A numeric item's accepted value and tolerance. */
+  readonly answer?: { readonly value: number; readonly tolerance: number };
 }
 
 /**
@@ -578,6 +690,8 @@ export interface Manifest {
   readonly numbering: NormalizedNumbering;
   /** How a check's and an example set's heading names its kind (`CourseConfig.blockLabels`). */
   readonly blockLabels: BlockLabels;
+  /** How the explanation cards start for a reader, defaults applied (`CourseConfig.cards`). */
+  readonly cards: NormalizedCards;
   /** Reader-facing identity + versions (the `[?]` About panel). */
   readonly about: ManifestAbout;
   readonly notation: {
@@ -597,6 +711,8 @@ export interface Manifest {
   /** The course's parts in config order, with their chapters and overview pages. */
   readonly parts: readonly ManifestPart[];
   readonly lessons: readonly ManifestLesson[];
+  /** Every docs page that is not a chapter, by id (v25). */
+  readonly pages: readonly ManifestPage[];
   /** Full competency prerequisite graph. */
   readonly prereqEdges: readonly PrereqEdge[];
   /** Equation identity (D7): every labelled display equation + the render-path lookup. */
@@ -660,8 +776,12 @@ export interface Manifest {
     readonly equations: readonly EquationDiagnostic[];
     /** `<Table>` identity checks (F-tables-figures) — same codes, `tab-` prefixed. */
     readonly tables: readonly TableDiagnostic[];
-    /** `<Figure>` identity checks (F-tables-figures) — same codes, `fig-` prefixed. */
-    readonly figures: readonly FigureDiagnostic[];
+    /**
+     * `<Figure>` identity checks (F-tables-figures) — same codes, `fig-`
+     * prefixed — and rule V3's `lab-katex-direct`: a file a lesson imports
+     * that calls KaTeX itself.
+     */
+    readonly figures: readonly (FigureDiagnostic | LabKatexDiagnostic)[];
     /** `<Diagram>` identity checks — same codes, `dia-` prefixed. */
     readonly diagrams: readonly DiagramDiagnostic[];
     /** Knowledge-check identity and `[[check-…]]` reference checks. */
@@ -691,7 +811,6 @@ export interface Manifest {
 
 // --- compile ---------------------------------------------------------
 
-const CITE_PATTERN = /\[@([a-z0-9][a-z0-9.-]*)(?:;[ \t\r\n]*([^\]]*))?\]/g;
 
 /** Distinct `[@id; locator]` occurrences in a body, in first-appearance order. */
 function lessonCitations(body: string): ManifestCitation[] {
@@ -700,13 +819,16 @@ function lessonCitations(body: string): ManifestCitation[] {
     .replace(/`[^`\n]*`/g, '');
   const seen = new Set<string>();
   const citations: ManifestCitation[] = [];
-  for (const match of withoutCode.matchAll(CITE_PATTERN)) {
-    const id = (match[1] ?? '').trim();
-    const locator = (match[2] ?? '').replace(/\s+/g, ' ').trim() || undefined;
-    const dedupeKey = `${id} ${locator ?? ''}`;
-    if (seen.has(dedupeKey)) continue;
-    seen.add(dedupeKey);
-    citations.push(locator === undefined ? { id } : { id, locator });
+  // A citation in a link's text renders as typed (`citation-in-link`).
+  for (const match of withoutLinkCitations(withoutCode).matchAll(CITATION_BRACKET)) {
+    for (const citation of bracketCitations(match[1] ?? '', match[2])) {
+      const id = citation.id;
+      const locator = citation.locator || undefined;
+      const dedupeKey = `${id} ${locator ?? ''}`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      citations.push(locator === undefined ? { id } : { id, locator });
+    }
   }
   return citations;
 }
@@ -770,7 +892,9 @@ function lessonNotationResolution(
           : 'local'
         : 'unresolved',
       definitionId: definitionId ?? null,
-      kind: reference.kind,
+      // A page's own references are prose or math; a definition's formula
+      // reference is reported as the definition reference it always was.
+      kind: reference.kind === 'formula' ? 'definition' : reference.kind,
       line: reference.source.line ?? null,
       column: reference.source.column ?? null,
     };
@@ -782,11 +906,14 @@ function lessonNotationBundle(
   definitionsById: ReadonlyMap<string, NotationDefinitionRecord>,
   resolution: readonly ManifestNotationResolution[],
   cardsByKey: ReadonlyMap<string, GlyphScopeEntry>,
+  derivedUses: readonly DerivedUse[] = [],
 ): ManifestLesson['notation'] {
   const definitions: ManifestLessonNotation[] = [];
+  const records: NotationDefinitionRecord[] = [];
   for (const definitionId of bundle?.definitionIds ?? []) {
     const definition = definitionsById.get(definitionId);
     if (!definition) continue;
+    records.push(definition);
     definitions.push({
       id: definition.id,
       key: definition.key,
@@ -794,7 +921,6 @@ function lessonNotationBundle(
       notation: definition.notation,
       label: definition.label,
       summary: definition.summary,
-      editorialStatus: definition.status,
       seeAlso: [...definition.seeAlso],
       glosses: [...definition.glosses],
       formulaScope: formulaGlyphScope({
@@ -810,12 +936,18 @@ function lessonNotationBundle(
       ...(definition.formula === undefined
         ? {}
         : { formula: definition.formula }),
+      ...(definition.range === undefined ? {} : { range: definition.range }),
     });
   }
   return {
     bindings: [...(bundle?.bindings ?? [])].map((binding) => ({ ...binding })),
     definitionIds: [...(bundle?.definitionIds ?? [])],
     definitions,
+    derived: derivedNotationEntries(
+      derivedUses,
+      new Map(records.map((record) => [record.key, record])),
+      cardsByKey,
+    ),
     resolution: [...resolution],
   };
 }
@@ -925,13 +1057,25 @@ export async function compileManifest(
     loadAbbreviationRegistryInput(),
   ]);
 
-  const registry = buildNotationRegistry(notationInput);
+  // Rule S10: a page that is not a chapter explains its symbols like a
+  // chapter does, so its references resolve through the same registry and its
+  // text and math pass the same gates. It stays out of `notationInput.lessons`,
+  // which is the chapter list every numbering and curriculum pass reads.
+  const nonChapterPages = loadNonChapterPages();
+  const withPages: typeof notationInput = {
+    ...notationInput,
+    lessons: [
+      ...notationInput.lessons,
+      ...nonChapterPages.map((page) => page.notation),
+    ],
+  };
+  const registry = buildNotationRegistry(withPages);
   // Cards a `formula` may name with `\explain{key}` (D15). Shared entries
   // only: a page-local symbol is not addressable from another entry.
   const cardsByKey = new Map<string, GlyphScopeEntry>(
     notationInput.sharedDefinitions.map((definition) => [
       definition.key,
-      { key: definition.key, notation: definition.notation },
+      scopeEntry(definition),
     ]),
   );
   const definitionsById = new Map(
@@ -945,27 +1089,74 @@ export async function compileManifest(
   const assessmentsInput = catalog.assessments as unknown as {
     id: string;
     title?: string;
-    items?: { id?: string; prompt?: string; explanation?: string }[];
+    items?: {
+      id?: string;
+      type?: string;
+      prompt?: string;
+      explanation?: string;
+      options?: { id?: string; label?: string }[];
+      correctOptionId?: string;
+      answer?: { value?: number; tolerance?: number };
+    }[];
   }[];
 
-  const curriculumIssues = validateCurriculum(catalog);
+  const contentRecords = loadContentRecords();
+  const curriculumIssues = [
+    ...validateCurriculum(catalog),
+    ...validateContentSchemas(contentRecords),
+    ...findRetiredKeys(contentRecords),
+    ...findUnsupportedKeys(contentRecords),
+    ...findMarkupInProps(contentRecords),
+  ];
   const alignmentIssues = validateNotationAlignment(registry, catalog);
   const mathEndAbbreviations = {
     allow: rules.strings('N12', 'allow'),
     deny: rules.strings('N12', 'deny'),
   };
+  // A heading's text is what the reader sees: a `[[key]]` term in it reads as
+  // its label, the page's own symbol first (rule S1 measures it, and the
+  // outline records it).
+  const sharedLabels = new Map(
+    notationInput.sharedDefinitions.map((definition) => [definition.key, definition.label]),
+  );
+  const localLabelsByLesson = new Map(
+    notationInput.lessons.map((lesson) => [
+      lesson.lessonId,
+      new Map(lesson.localDefinitions.map((definition) => [definition.key, definition.label])),
+    ]),
+  );
+  const termLabel = (lessonId: string, key: string): string | undefined =>
+    localLabelsByLesson.get(lessonId)?.get(key) ?? sharedLabels.get(key);
+  // Rule N23 and the derived cards a page uses: one resolver pass over every
+  // body. The cards are built whatever the rule's switch says; its findings
+  // drop with the rule (`dropDisabled`) and yield to a waiver.
+  const indexGate = gateIndices(
+    withPages.lessons,
+    new Map(
+      notationInput.sharedDefinitions.map((definition) => [definition.key, definition]),
+    ),
+    {
+      assessments: assessmentsInput,
+      lessonAssessments: catalog.lessons.map((lesson) => ({
+        lessonId: lesson.id,
+        assessmentIds: lesson.assessments,
+      })),
+    },
+  );
   const mathIssues = [
+    ...indexGate.diagnostics,
     ...gateContentMath({
-      notationInput,
+      notationInput: withPages,
       assessments: assessmentsInput,
       lessonAssessments: catalog.lessons.map((lesson) => ({
         lessonId: lesson.id,
         assessmentIds: lesson.assessments,
       })),
     }),
+    ...gateMdxExpressions(withPages.lessons),
     ...(rules.isEnabled('N9')
       ? [
-          ...gateProseNotation(notationInput.lessons, {
+          ...gateProseNotation(withPages.lessons, {
             allowSpelledUnits: rules.strings('N9', 'allow'),
           }),
           ...gateProseNotationInAssessments(assessmentsInput, {
@@ -975,13 +1166,13 @@ export async function compileManifest(
       : []),
     ...(rules.isEnabled('N12')
       ? [
-          ...gateMathPunctuation(notationInput.lessons, mathEndAbbreviations),
+          ...gateMathPunctuation(withPages.lessons, mathEndAbbreviations),
           ...gateMathPunctuationInAssessments(assessmentsInput, mathEndAbbreviations),
         ]
       : []),
     ...(rules.isEnabled('N14')
       ? gateAbbreviations({
-          notationInput,
+          notationInput: withPages,
           abbreviations: abbreviationsInput,
           courseAbbreviations: rules.settings('N14'),
         })
@@ -989,6 +1180,7 @@ export async function compileManifest(
     ...(rules.isEnabled('S1')
       ? gateHeadingLength(notationInput.lessons, {
           maxLength: rules.number('S1', 'maxLength'),
+          labelFor: termLabel,
         })
       : []),
     ...gateHeadingStructure(notationInput.lessons, {
@@ -998,7 +1190,9 @@ export async function compileManifest(
     // The course's own rules (`courseRules`): one pass for every enabled `X`
     // rule that carries a `forbid` pattern. A disabled one, and a guide rule
     // with no pattern, do no work here.
-    ...gateCourseRules(notationInput.lessons, rules.course),
+    ...gateCourseRules(withPages.lessons, rules.course),
+    // S10 is locked: a float on a non-chapter page has no number to render.
+    ...gateNonChapterPages(nonChapterPages),
   ];
 
   // Pre-render every assessment `prompt` / `explanation` into text/math
@@ -1015,22 +1209,57 @@ export async function compileManifest(
     assessmentsInput.map((assessment) => [assessment.id, assessment]),
   );
   const assessmentContent: ManifestAssessmentItemContent[] = [];
+  // An assessment is page math: its indexed symbols take derived cards
+  // (rule N23), which the lesson then ships with its body's.
+  const assessmentDerived = new Map<string, Map<string, DerivedUse>>();
   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);
+    const derived = new Map<string, DerivedUse>();
+    assessmentDerived.set(lesson.id, derived);
+    const page = { derive: true, derived };
     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;
+        const numeric =
+          item.type === 'numeric' &&
+          typeof item.answer?.value === 'number' &&
+          typeof item.answer.tolerance === 'number';
         assessmentContent.push({
           lessonId: lesson.id,
           assessmentId,
           itemId: item.id,
-          promptSegments: splitMixedContent(item.prompt ?? '', scope),
-          explanationSegments: splitMixedContent(item.explanation ?? '', scope),
+          promptSegments: splitMixedContent(item.prompt ?? '', scope, page),
+          explanationSegments: splitMixedContent(item.explanation ?? '', scope, page),
+          type: item.type === 'numeric' ? 'numeric' : 'single-choice',
+          ...(item.options
+            ? {
+                options: item.options.flatMap((option) =>
+                  option.id
+                    ? [
+                        {
+                          id: option.id,
+                          label: option.label ?? '',
+                          labelSegments: splitMixedContent(option.label ?? '', scope, page),
+                        },
+                      ]
+                    : [],
+                ),
+              }
+            : {}),
+          ...(item.correctOptionId ? { correctOptionId: item.correctOptionId } : {}),
+          ...(numeric
+            ? {
+                answer: {
+                  value: item.answer!.value!,
+                  tolerance: item.answer!.tolerance!,
+                },
+              }
+            : {}),
         });
       }
     }
@@ -1060,9 +1289,44 @@ export async function compileManifest(
   const lessonSlugs = [...notationInput.lessons]
     .map((lesson) => lesson.lessonId.replace(/\./g, '/'))
     .sort();
-  const configuredParts = coursePartsOf(courseConfig);
-  const overviewPages = loadPartOverviews(configuredParts);
+  // A part takes a sidebar group and an ordinal once it has a chapter or an
+  // overview page; one with neither yet (planned, its directory not written)
+  // is left out of both, with a warning, so every part number — a lesson's,
+  // `parts[]`, the LaTeX export's — counts the same parts.
+  const listedParts = coursePartsOf(courseConfig);
+  const overviewPages = loadPartOverviews(listedParts);
   const overviewByDir = new Map(overviewPages.map((page) => [page.dir, page]));
+  const hasChapter = (dir: string) => lessonSlugs.some((slug) => slug.startsWith(`${dir}/`));
+  const configuredParts = listedParts.filter(
+    (part) => hasChapter(part.dir) || overviewByDir.has(part.dir),
+  );
+  for (const part of listedParts) {
+    if (configuredParts.includes(part)) continue;
+    curriculumIssues.push({
+      kind: 'part-empty',
+      severity: 'warning',
+      message:
+        `course.settings.json \`parts\` lists "${part.dir}" (${JSON.stringify(part.label)}), but ` +
+        `content/docs/${part.dir}/ has no chapter and no overview page yet, so the part ` +
+        'is left out of the sidebar and the numbering until it has one.',
+    });
+  }
+  // A lesson whose directory no part lists has no part, no chapter number and
+  // no place in the sidebar.
+  const partDirs = new Set(listedParts.map((part) => part.dir));
+  for (const lesson of notationInput.lessons) {
+    const dir = lesson.lessonId.split('.')[0] ?? '';
+    if (partDirs.has(dir)) continue;
+    curriculumIssues.push({
+      kind: 'lesson-outside-parts',
+      message:
+        `${lesson.source.file} is in content/docs/${dir}/, which no part in ` +
+        `course.settings.json \`parts\` lists, so it has no part, no chapter number and no ` +
+        `place in the sidebar. Add { "dir": "${dir}", "label": "…" } to \`parts\`, or move the ` +
+        "lesson into a part's directory.",
+      file: lesson.source.file,
+    });
+  }
   // S2: every authored part page carries its bridge and scope paragraphs.
   if (rules.isEnabled('S2')) {
     mathIssues.push(
@@ -1077,10 +1341,12 @@ export async function compileManifest(
   }
   // Per-place waivers: drop the located findings each one covers, and
   // report the waivers themselves — a stale one is a warning, a bad one an
-  // error. Only lesson bodies are scanned; a part page has no waivable rule.
+  // error. Chapters and non-chapter pages are scanned alike, since the text
+  // and math gates run on both; S2 and S10 are per-file or locked, so no
+  // waiver reaches them.
   const waiverDiagnostics: WaiverDiagnostic[] = [];
   const waiverRules = { courseRules: rules.course };
-  const waivers = notationInput.lessons.flatMap((lesson) => {
+  const waivers = withPages.lessons.flatMap((lesson) => {
     const collected = collectWaivers(lesson, waiverRules);
     waiverDiagnostics.push(...collected.diagnostics);
     return collected.waivers;
@@ -1127,12 +1393,14 @@ export async function compileManifest(
   >();
   const chapterScoped = numberingSettings.floats === 'chapter';
   let partCursor = 0;
-  for (const group of sidebar) {
+  // The part groups, in `configuredParts` order; the static Reference group
+  // after them is no part. An overview-only part counts, as `parts[]` does.
+  for (const group of sidebar.slice(0, configuredParts.length)) {
+    partCursor += 1;
     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;
+    if (lessonIds.length === 0) continue;
     // Running totals for this part, advanced one chapter at a time; they
     // only reach a number under the part scope.
     const used = {
@@ -1184,6 +1452,7 @@ export async function compileManifest(
             ? { prefix: `${placement.part}.${placement.chapter}` }
             : {}),
           depth: numberingSettings.sections.depth,
+          labelFor: (key: string) => termLabel(lesson.lessonId, key),
         }) as ManifestLesson['headings'],
       ];
     }),
@@ -1199,6 +1468,7 @@ export async function compileManifest(
           (heading) => heading.slug,
         ),
       })),
+      nonChapterPages.map((page) => page.slug),
     ),
   );
 
@@ -1337,6 +1607,52 @@ export async function compileManifest(
       }),
     ]),
   );
+  // A heading's anchor must not be one the engine gives something else on
+  // the page (`heading-anchor-collision`, keyed-floats invariant).
+  const engineAnchorsFor = (lessonId: string, body: string): Map<string, string> => {
+    const slug = lessonId.replace(/\./g, '/');
+    const anchors = new Map<string, string>();
+    const keyed = (
+      floats: readonly { readonly key: string }[],
+      prefix: string,
+      owner: (key: string) => string,
+    ) => {
+      for (const float of floats) anchors.set(`${prefix}-${float.key}`, owner(float.key));
+    };
+    keyed(equationsBySlug.get(slug) ?? [], 'eq', (key) => `the equation labelled eq:${key}`);
+    keyed(tablesBySlug.get(slug) ?? [], 'tab', (key) => `<Table id="${key}">`);
+    keyed(figuresBySlug.get(slug) ?? [], 'fig', (key) => `<Figure id="${key}">`);
+    keyed(diagramsBySlug.get(slug) ?? [], 'dia', (key) => `<Diagram id="${key}">`);
+    keyed(examplesBySlug.get(slug) ?? [], 'ex', (key) => `<CompactExamples id="${key}">`);
+    for (const check of checksBySlug.get(slug) ?? []) {
+      anchors.set(knowledgeCheckAnchorId(check.key), `the knowledge check ${check.key}`);
+    }
+    for (const [name, prefix] of [
+      ['Memo', 'memo'],
+      ['ShortNote', 'short-note'],
+    ] as const) {
+      const tag = new RegExp(`<${name}\\b[^>]*?\\bid=["']([^"']+)["']`, 'g');
+      for (const match of body.matchAll(tag)) {
+        anchors.set(`${prefix}-${match[1]}`, `<${name} id="${match[1]}">`);
+      }
+    }
+    if (deriveSources(body).length > 0) {
+      anchors.set('references', 'the References section generated from the page’s citations');
+    }
+    return anchors;
+  };
+  mathIssues.push(
+    ...validateHeadingAnchors(
+      notationInput.lessons.map((lesson) => ({
+        file: lesson.source.file,
+        body: lesson.body,
+        ...(lesson.bodyLine === undefined ? {} : { bodyLine: lesson.bodyLine }),
+        headings: headingsByLessonId.get(lesson.lessonId) ?? [],
+        anchors: engineAnchorsFor(lesson.lessonId, lesson.body),
+      })),
+    ),
+  );
+
   // The blocks that draw an `<h2>` where their tag stands, placed after the
   // outline heading they follow — "On this page" lists them there (v23).
   // `<AssessmentSet />` draws every check of the lesson, or the one its `id`
@@ -1369,6 +1685,16 @@ export async function compileManifest(
       },
     );
   };
+  // Rule V3: the course files a lesson's imports reach draw math through
+  // `renderLabMath`, never KaTeX itself.
+  const labKatexDiagnostics = validateLabKatexImports(
+    notationInput.lessons.map((lesson) => ({
+      lessonId: lesson.lessonId,
+      file: lesson.source.file,
+      body: lesson.body,
+    })),
+    REPOSITORY_ROOT,
+  );
   const rawFloatDiagnostics = validateRawFloats(
     notationInput.lessons.map((lesson) => ({
       lessonId: lesson.lessonId,
@@ -1412,7 +1738,6 @@ export async function compileManifest(
       ...(frontmatter.studyMinutes === undefined
         ? {}
         : { studyMinutes: frontmatter.studyMinutes }),
-      status: meta.status,
       teaches: [...teaches],
       requires: [...meta.requires],
       assumptions: [...meta.assumptions],
@@ -1442,18 +1767,38 @@ export async function compileManifest(
           availableDefinitionIds,
         ),
         cardsByKey,
+        [
+          ...(indexGate.derivedByLesson.get(id) ?? []),
+          ...(assessmentDerived.get(id)?.values() ?? []),
+        ],
       ),
     });
   }
   lessons.sort((a, b) => a.id.localeCompare(b.id));
+  const pages: ManifestPage[] = nonChapterPages
+    .map((page) => ({
+      id: page.id,
+      slug: page.slug,
+      file: page.file,
+      notation: lessonNotationBundle(
+        bundlesByLesson.get(page.id),
+        definitionsById,
+        lessonNotationResolution(
+          page.notation,
+          definitionsById,
+          availableDefinitionIds,
+        ),
+        cardsByKey,
+        indexGate.derivedByLesson.get(page.id),
+      ),
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
 
   const consistencyIssues = runConsistencyChecks({
     registry,
-    notationInput,
+    notationInput: withPages,
     specs: loadNotationSpecs(),
-    catalog,
     lintIgnore: loadLintIgnore(),
-    conventions: courseConfig.conventions,
     operators: rules.settings('N8'),
     romanLabels: rules.settings('N10'),
     accents: rules.settings('N22'),
@@ -1528,6 +1873,7 @@ export async function compileManifest(
     disclosure: normalizeDisclosure(courseConfig),
     numbering: numberingSettings,
     blockLabels,
+    cards: normalizeCards(courseConfig),
     about,
     notation: {
       definitions: registry.definitions,
@@ -1543,6 +1889,7 @@ export async function compileManifest(
     sidebar,
     parts: manifestParts,
     lessons,
+    pages,
     prereqEdges,
     equations: {
       labels: equationValidation.labels,
@@ -1578,7 +1925,7 @@ export async function compileManifest(
       consistency: dropDisabled(consistencyIssues, off),
       equations: dropDisabled(equationValidation.diagnostics, off),
       tables: dropDisabled(tableValidation.diagnostics, off),
-      figures: dropDisabled(figureValidation.diagnostics, off),
+      figures: dropDisabled([...figureValidation.diagnostics, ...labKatexDiagnostics], off),
       diagrams: dropDisabled(diagramValidation.diagnostics, off),
       checks: dropDisabled(checkValidation.diagnostics, off),
       examples: dropDisabled(exampleValidation.diagnostics, off),