explico 0.13.1 → 0.14.0

package/dist/compiler/manifest.js

@@ -46,7 +46,9 @@ import {
 import {
   gateContentMath,
   pageScope,
-  scopeEntry
+  scopeEntry,
+  scopeLocals,
+  suspendedOperators
 } from "../reference/gate-math.js";
 import { gateIndices } from "../reference/gate-indices.js";
 import { derivedNotationEntries } from "../reference/derived-entries.js";
@@ -81,14 +83,19 @@ import {
 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 { pageScopeLessonIds, resolvePageReferenceId } from "../reference/references.js";
 import {
   coursePartsOf,
   normalizeBlockLabels,
   normalizeCards,
+  normalizeSidebarMarks,
+  normalizeSidebarEditions,
+  normalizeReadingMemory,
+  normalizeAppearance,
   normalizeLessonExports,
   normalizeDisclosure,
-  normalizeNumbering
+  normalizeNumbering,
+  normalizeDeck
 } from "./course-config.js";
 import {
   disabledCodes,
@@ -104,6 +111,13 @@ import {
 import {
   resolveKnowledgeVersion
 } from "./knowledge-version.js";
+import {
+  nextPageVersions,
+  PAGE_VERSIONS_FILE,
+  pageSourceDigest,
+  readPageVersions,
+  sinceOf
+} from "./page-versions.js";
 import {
   loadAbbreviationRegistryInput,
   loadContentRecords,
@@ -113,15 +127,24 @@ import {
   loadNonChapterPages,
   loadNotationSpecs,
   loadPartOverviews,
-  loadSourceRecords
+  loadSourceRecords,
+  loadDeckFiles,
+  loadDeckNotationPages,
+  loadLessonFiles
 } from "./collections.js";
+import { buildDecks, chapterEquationLatex } from "./decks.js";
+import { readDeckSource } from "../reference/deck-source.js";
+import { coveredSections } from "../reference/decks-validate.js";
 import {
   buildSidebar,
   deriveSources,
   isLessonSlug,
-  lessonIdFromSlug
+  lessonIdFromSlug,
+  mergeTrackOrder,
+  sidebarLessonSlug,
+  withPartDeckFrames
 } from "./lesson-derivation.js";
-const MANIFEST_SCHEMA_VERSION = 31;
+const MANIFEST_SCHEMA_VERSION = 37;
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
 const MANIFEST_PATH = join(REPOSITORY_ROOT, "build", "manifest.json");
@@ -173,11 +196,11 @@ function contentHashes() {
   return { content, contentTree: `sha256:${tree.digest("hex")}` };
 }
 function lessonNotationResolution(lesson, definitionsById, availableDefinitionIds) {
-  const scope = { kind: "page", lessonId: lesson.lessonId };
+  const scopes = pageScopeLessonIds(lesson);
   return lesson.references.map((reference) => {
-    const definitionId = resolveReferenceId(
+    const definitionId = resolvePageReferenceId(
       reference.key,
-      scope,
+      scopes,
       availableDefinitionIds
     );
     const definition = definitionId === void 0 ? void 0 : definitionsById.get(definitionId);
@@ -245,29 +268,16 @@ function studyMinutesRange(value) {
   return void 0;
 }
 function lessonFrontmatterById() {
-  const base = join(CONTENT_ROOT, "docs");
   const result = /* @__PURE__ */ new Map();
-  const walk = (directory) => {
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-      const path = join(directory, entry.name);
-      if (entry.isDirectory()) {
-        walk(path);
-        continue;
-      }
-      if (!entry.isFile() || !/\.mdx?$/.test(entry.name)) continue;
-      const slug = relative(base, path).replace(/\\/g, "/");
-      if (!isLessonSlug(slug)) continue;
-      const id = slug.replace(/\.(md|mdx)$/, "").replace(/\//g, ".");
-      const data = parseFrontmatter(readFileSync(path, "utf8")).frontmatter ?? {};
-      const studyMinutes = studyMinutesRange(data.studyMinutes);
-      result.set(id, {
-        title: typeof data.title === "string" ? data.title : id,
-        description: typeof data.description === "string" ? data.description : "",
-        ...studyMinutes === void 0 ? {} : { studyMinutes }
-      });
-    }
-  };
-  walk(base);
+  for (const { path, lessonId: id } of loadLessonFiles()) {
+    const data = parseFrontmatter(readFileSync(path, "utf8")).frontmatter ?? {};
+    const studyMinutes = studyMinutesRange(data.studyMinutes);
+    result.set(id, {
+      title: typeof data.title === "string" ? data.title : id,
+      description: typeof data.description === "string" ? data.description : "",
+      ...studyMinutes === void 0 ? {} : { studyMinutes }
+    });
+  }
   return result;
 }
 async function compileManifest(courseConfig) {
@@ -280,17 +290,36 @@ async function compileManifest(courseConfig) {
   const off = disabledCodes(rules);
   const numberingSettings = normalizeNumbering(courseConfig);
   const blockLabels = normalizeBlockLabels(courseConfig);
+  const deckSettings = normalizeDeck(courseConfig);
   const [catalog, notationInput, abbreviationsInput] = await Promise.all([
     loadCurriculumCatalog(),
     loadNotationRegistryInput(),
     loadAbbreviationRegistryInput()
   ]);
   const nonChapterPages = loadNonChapterPages();
+  const deckFiles = loadDeckFiles();
+  const lessonDeckFiles = deckFiles.filter((deck) => deck.scope === "lesson");
+  const trackRank = new Map(
+    mergeTrackOrder(catalog.tracks.map((track) => ({ id: track.id, lessons: track.lessons }))).map(
+      (lessonId, index) => [lessonId, index]
+    )
+  );
+  const readingOrder = (lessonIds) => [...lessonIds].sort(
+    (left, right) => (trackRank.get(left) ?? Number.POSITIVE_INFINITY) - (trackRank.get(right) ?? Number.POSITIVE_INFINITY) || left.localeCompare(right)
+  );
+  const deckPages = loadDeckNotationPages(deckFiles, { order: readingOrder });
+  const deckLessonIds = new Set(
+    loadLessonFiles().filter((file) => file.edition === "deck").map((file) => file.lessonId)
+  );
+  const isChapter = (lessonId) => !deckLessonIds.has(lessonId);
+  const deckPageIds = new Set(deckPages.map((page) => page.notation.lessonId));
+  const chapterInputs = notationInput.lessons.filter((lesson) => isChapter(lesson.lessonId));
   const withPages = {
     ...notationInput,
     lessons: [
       ...notationInput.lessons,
-      ...nonChapterPages.map((page) => page.notation)
+      ...nonChapterPages.map((page) => page.notation),
+      ...deckPages.map((page) => page.notation)
     ]
   };
   const registry = buildNotationRegistry(withPages);
@@ -325,9 +354,9 @@ async function compileManifest(courseConfig) {
     notationInput.sharedDefinitions.map((definition) => [definition.key, definition.label])
   );
   const localLabelsByLesson = new Map(
-    notationInput.lessons.map((lesson) => [
+    withPages.lessons.map((lesson) => [
       lesson.lessonId,
-      new Map(lesson.localDefinitions.map((definition) => [definition.key, definition.label]))
+      new Map(scopeLocals(lesson).map((definition) => [definition.key, definition.label]))
     ])
   );
   const termLabel = (lessonId, key) => localLabelsByLesson.get(lessonId)?.get(key) ?? sharedLabels.get(key);
@@ -372,18 +401,26 @@ async function compileManifest(courseConfig) {
       abbreviations: abbreviationsInput,
       courseAbbreviations: rules.settings("N14")
     }) : [],
-    ...rules.isEnabled("S1") ? gateHeadingLength(notationInput.lessons, {
+    ...rules.isEnabled("S1") ? gateHeadingLength(chapterInputs, {
       maxLength: rules.number("S1", "maxLength"),
       labelFor: termLabel
     }) : [],
-    ...gateHeadingStructure(notationInput.lessons, {
+    ...gateHeadingStructure(chapterInputs, {
       levels: rules.isEnabled("S6"),
       adjacency: rules.isEnabled("S7")
     }),
     // 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(withPages.lessons, rules.course),
+    // A course rule about one edition is checked on that edition's pages.
+    ...gateCourseRules(
+      withPages.lessons.filter((lesson) => isChapter(lesson.lessonId) && !deckPageIds.has(lesson.lessonId)),
+      rules.course.filter((rule) => rule.editions !== "deck")
+    ),
+    ...gateCourseRules(
+      withPages.lessons.filter((lesson) => !isChapter(lesson.lessonId) || deckPageIds.has(lesson.lessonId)),
+      rules.course.filter((rule) => rule.editions !== "chapter")
+    ),
     // S10 is locked: a float on a non-chapter page has no number to render.
     ...gateNonChapterPages(nonChapterPages)
   ];
@@ -472,6 +509,11 @@ async function compileManifest(courseConfig) {
       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.`
     });
   }
+  const configuredDirs = new Set(configuredParts.map((part) => part.dir));
+  const partDeckFiles = deckFiles.filter(
+    (deck) => deck.scope === "part" && configuredDirs.has(deck.partDir)
+  );
+  const partChapterNames = (dir) => lessonSlugs.filter((slug) => slug.startsWith(`${dir}/`) && isChapter(lessonIdFromSlug(slug))).map((slug) => slug.slice(dir.length + 1));
   const partDirs = new Set(listedParts.map((part) => part.dir));
   for (const lesson of notationInput.lessons) {
     const dir = lesson.lessonId.split(".")[0] ?? "";
@@ -493,16 +535,6 @@ async function compileManifest(courseConfig) {
       )
     );
   }
-  const waiverDiagnostics = [];
-  const waiverRules = { courseRules: rules.course };
-  const waivers = withPages.lessons.flatMap((lesson) => {
-    const collected = collectWaivers(lesson, waiverRules);
-    waiverDiagnostics.push(...collected.diagnostics);
-    return collected.waivers;
-  });
-  const waived = applyWaivers(mathIssues, waivers, waiverRules);
-  mathIssues.splice(0, mathIssues.length, ...waived.kept);
-  waiverDiagnostics.push(...waived.unused);
   const sidebar = buildSidebar(
     catalog.tracks.map((track) => ({ id: track.id, lessons: track.lessons })),
     lessonSlugs,
@@ -513,7 +545,31 @@ async function compileManifest(courseConfig) {
     {
       floatIndex: [".mdx", ".md"].some(
         (extension) => existsSync(join(CONTENT_ROOT, "docs", `figures-and-tables${extension}`))
-      )
+      ),
+      // A deck beside its chapter is listed right under it.
+      decks: new Map(
+        lessonDeckFiles.filter((deck) => deck.chapterPath !== void 0 && deck.inPart).map((deck) => [deck.lessonSlug, deck.route])
+      ),
+      // A deck with no chapter is the lesson: its row carries the deck's glyph.
+      slidesFirst: new Set(
+        lessonDeckFiles.filter((deck) => deck.chapterPath === void 0 && deck.inPart).map((deck) => deck.lessonSlug)
+      ),
+      // A part's deck follows the part's Overview; a chapter it covers that
+      // has no deck of its own links into it, at its section's divider.
+      partDecks: new Map(
+        partDeckFiles.map((deck) => {
+          const { covered } = coveredSections(readDeckSource(deck.body), new Set(partChapterNames(deck.partDir)));
+          return [
+            deck.partDir,
+            {
+              route: deck.route,
+              covers: new Map(covered.map(({ name, position }) => [`${deck.partDir}/${name}`, position + 2]))
+            }
+          ];
+        })
+      ),
+      // Each edition's row names its lesson, which the sidebar's own row shows.
+      titleOf: (slug) => frontmatterById.get(lessonIdFromSlug(slug))?.title
     }
   );
   const bodyByLessonId = new Map(
@@ -524,7 +580,10 @@ async function compileManifest(courseConfig) {
   let partCursor = 0;
   for (const group of sidebar.slice(0, configuredParts.length)) {
     partCursor += 1;
-    const lessonIds = group.items.filter((item) => typeof item === "string").map(lessonIdFromSlug);
+    const lessonIds = group.items.flatMap((item) => {
+      const slug = sidebarLessonSlug(item);
+      return slug === void 0 ? [] : [lessonIdFromSlug(slug)];
+    });
     if (lessonIds.length === 0) continue;
     const used = {
       equations: 0,
@@ -536,7 +595,7 @@ async function compileManifest(courseConfig) {
     };
     let chapterCursor = 0;
     for (const lessonId of lessonIds) {
-      const body = bodyByLessonId.get(lessonId) ?? "";
+      const body = isChapter(lessonId) ? bodyByLessonId.get(lessonId) ?? "" : "";
       const chapter = ++chapterCursor;
       placementByLessonId.set(lessonId, {
         part: partCursor,
@@ -565,7 +624,8 @@ async function compileManifest(courseConfig) {
       return [
         lesson.lessonId,
         scanSectionHeadings(lesson.body, {
-          ...placement ? { prefix: `${placement.part}.${placement.chapter}` } : {},
+          // A deck's headings are sections and frames, numbered as frames.
+          ...placement && isChapter(lesson.lessonId) ? { prefix: `${placement.part}.${placement.chapter}` } : {},
           depth: numberingSettings.sections.depth,
           labelFor: (key) => termLabel(lesson.lessonId, key)
         })
@@ -615,7 +675,7 @@ async function compileManifest(courseConfig) {
       } : {}
     };
   });
-  const floatInputs = (kind) => notationInput.lessons.map((lesson) => {
+  const floatInputs = (kind) => chapterInputs.map((lesson) => {
     const placement = placementByLessonId.get(lesson.lessonId);
     return {
       lessonId: lesson.lessonId,
@@ -725,6 +785,7 @@ async function compileManifest(courseConfig) {
     )
   );
   const titledBlocksFor = (lessonId) => {
+    if (!isChapter(lessonId)) return [];
     const slug = lessonId.replace(/\./g, "/");
     const body = bodyByLessonId.get(lessonId) ?? "";
     const headings = headingsByLessonId.get(lessonId) ?? [];
@@ -749,7 +810,7 @@ async function compileManifest(courseConfig) {
     );
   };
   const labKatexDiagnostics = validateLabKatexImports(
-    notationInput.lessons.map((lesson) => ({
+    [...notationInput.lessons, ...deckPages.map((page) => page.notation)].map((lesson) => ({
       lessonId: lesson.lessonId,
       file: lesson.source.file,
       body: lesson.body
@@ -757,13 +818,112 @@ async function compileManifest(courseConfig) {
     REPOSITORY_ROOT
   );
   const rawFloatDiagnostics = validateRawFloats(
-    notationInput.lessons.map((lesson) => ({
+    [...notationInput.lessons, ...deckPages.map((page) => page.notation)].map((lesson) => ({
       lessonId: lesson.lessonId,
       slug: lesson.lessonId.replace(/\./g, "/"),
       file: lesson.source.file,
       body: lesson.body
     }))
   );
+  const pageInputById = new Map(withPages.lessons.map((lesson) => [lesson.lessonId, lesson]));
+  const chapterBodyById = new Map(chapterInputs.map((lesson) => [lesson.lessonId, lesson.body]));
+  const floatNumbers = (floats) => new Map((floats ?? []).map((float) => [float.key, float.number]));
+  const outcomeById = new Map(
+    catalog.competencies.flatMap((competency) => {
+      const outcome = competency.outcome;
+      return typeof outcome === "string" ? [[competency.id, outcome]] : [];
+    })
+  );
+  const chapterFloatsOf = (lessonId) => {
+    const slug = lessonId.replace(/\./g, "/");
+    const chapterBody = chapterBodyById.get(lessonId);
+    const latex = chapterBody === void 0 ? /* @__PURE__ */ new Map() : chapterEquationLatex(chapterBody);
+    return {
+      equations: new Map(
+        (equationsBySlug.get(slug) ?? []).map((equation) => [
+          equation.key,
+          { number: equation.number, ...latex.has(equation.key) ? { latex: latex.get(equation.key) } : {} }
+        ])
+      ),
+      figures: floatNumbers(figuresBySlug.get(slug)),
+      tables: floatNumbers(tablesBySlug.get(slug)),
+      diagrams: floatNumbers(diagramsBySlug.get(slug))
+    };
+  };
+  const outcomesOf = (lessonId) => (lessonMetaById.get(lessonId)?.teaches ?? []).flatMap((id) => {
+    const outcome = outcomeById.get(id);
+    return outcome ? [outcome] : [];
+  });
+  const deckParts = new Map(
+    partDeckFiles.map((deck) => {
+      const part = manifestParts.find((entry) => entry.dir === deck.partDir);
+      const lessonIds = part?.lessons ?? [];
+      const nameOf = (lessonId) => lessonId.replace(/\./g, "/").slice(deck.partDir.length + 1);
+      return [
+        deck.partDir,
+        {
+          label: part?.label ?? deck.partDir,
+          chapters: lessonIds.filter(isChapter).map((lessonId) => ({
+            name: nameOf(lessonId),
+            slug: lessonId.replace(/\./g, "/"),
+            teaches: lessonMetaById.get(lessonId)?.teaches ?? [],
+            outcomes: outcomesOf(lessonId),
+            floats: chapterFloatsOf(lessonId)
+          })),
+          slidesFirst: lessonIds.filter((lessonId) => !isChapter(lessonId)).map(nameOf)
+        }
+      ];
+    })
+  );
+  const deckModel = buildDecks({
+    decks: deckFiles,
+    settings: deckSettings,
+    rules: {
+      maxWords: rules.number("D2", "maxWords"),
+      maxBullets: rules.number("D2", "maxBullets"),
+      maxTitleLength: rules.number("D5", "maxLength"),
+      maxSteps: rules.number("D6", "maxSteps"),
+      maxNewSymbols: rules.number("D9", "maxNewSymbols")
+    },
+    lessons: new Map(
+      lessonDeckFiles.map((deck) => [
+        deck.lessonId,
+        {
+          title: frontmatterById.get(deck.lessonId)?.title ?? deck.lessonId,
+          teaches: lessonMetaById.get(deck.lessonId)?.teaches ?? [],
+          outcomes: outcomesOf(deck.lessonId),
+          ...deck.chapterPath === void 0 ? {} : { chapterFloats: chapterFloatsOf(deck.lessonId) }
+        }
+      ])
+    ),
+    parts: deckParts,
+    // As the title frame shows them (`titleFrameNode` in `deck-remark.mjs`).
+    course: {
+      name: courseConfig.about.materialName ?? courseConfig.title,
+      authors: courseConfig.about.authors.map((author) => author.name)
+    },
+    scopeOf: (pageId) => {
+      const page = pageInputById.get(pageId);
+      return page === void 0 ? [] : pageScope(page, cardsByKey);
+    },
+    suspendedOf: (pageId) => {
+      const page = pageInputById.get(pageId);
+      return page === void 0 ? [] : suspendedOperators(page);
+    },
+    labelFor: termLabel
+  });
+  mathIssues.push(...deckModel.diagnostics);
+  const sidebarWithFrames = withPartDeckFrames(sidebar, deckModel.decks);
+  const waiverDiagnostics = [];
+  const waiverRules = { courseRules: rules.course };
+  const waivers = withPages.lessons.flatMap((lesson) => {
+    const collected = collectWaivers(lesson, waiverRules);
+    waiverDiagnostics.push(...collected.diagnostics);
+    return collected.waivers;
+  });
+  const waived = applyWaivers(mathIssues, waivers, waiverRules);
+  mathIssues.splice(0, mathIssues.length, ...waived.kept);
+  waiverDiagnostics.push(...waived.unused);
   const lessons = [];
   for (const notationLesson of notationInput.lessons) {
     const id = notationLesson.lessonId;
@@ -777,6 +937,10 @@ async function compileManifest(courseConfig) {
     lessons.push({
       id,
       slug: id.replace(/\./g, "/"),
+      editions: [
+        ...isChapter(id) ? ["chapter"] : [],
+        ...lessonDeckFiles.some((deck) => deck.lessonId === id) ? ["deck"] : []
+      ],
       // 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.
@@ -876,6 +1040,107 @@ async function compileManifest(courseConfig) {
     declaredVersion: courseConfig.about.version,
     file: relative(REPOSITORY_ROOT, knowledgeChangelogPath).replace(/\\/g, "/")
   });
+  const trackPageVersions = !rules.disabled.includes("C5");
+  const previousVersions = trackPageVersions ? readPageVersions(join(CONTENT_ROOT, "versions.json"), PAGE_VERSIONS_FILE) : { record: void 0, diagnostics: [] };
+  const digestOf = (file) => hashes.content[file] ?? "missing";
+  const presentFiles = (files) => files.filter((file) => hashes.content[file] !== void 0);
+  const sourceFileById = /* @__PURE__ */ new Map();
+  for (const record of contentRecords) {
+    const file = record.file.replace(/\\/g, "/");
+    if (file.startsWith("content/sources/") && typeof record.data.id === "string") {
+      sourceFileById.set(record.data.id, file);
+    }
+  }
+  const sharedEntryInputs = (definitionIds) => definitionIds.flatMap((definitionId) => {
+    const definition = definitionsById.get(definitionId);
+    return definition?.kind === "shared" ? [{ label: `notation ${definition.source.file}`, digest: digestOf(definition.source.file) }] : [];
+  });
+  const recalledFloatFacts = (recalledFrom) => Object.fromEntries(
+    Object.entries(recalledFrom).map(([ref, chapter]) => {
+      const [, prefix, key] = /^(eq|fig|tab|dia)-(.+)$/u.exec(ref) ?? [];
+      const floats = prefix === "eq" ? equationsBySlug : prefix === "fig" ? figuresBySlug : prefix === "tab" ? tablesBySlug : diagramsBySlug;
+      const float = floats.get(chapter)?.find((entry) => entry.key === key);
+      const latex = prefix === "eq" ? chapterFloatsOf(chapter.replace(/\//g, ".")).equations.get(key ?? "")?.latex : void 0;
+      return [ref, { chapter, ...float, ...latex === void 0 ? {} : { latex } }];
+    })
+  );
+  const trackedPages = [
+    ...lessons.map((lesson) => ({
+      slug: lesson.slug,
+      source: pageSourceDigest(
+        [
+          { label: `page ${lesson.file}`, digest: digestOf(lesson.file) },
+          ...presentFiles([lesson.file.replace(/\.mdx?$/u, ".checks.yml")]).map((file) => ({
+            label: `checks ${file}`,
+            digest: digestOf(file)
+          })),
+          ...presentFiles(lesson.assessments.map((id) => `content/assessments/${id}.json`)).map((file) => ({
+            label: `assessment ${file}`,
+            digest: digestOf(file)
+          })),
+          ...sharedEntryInputs(lesson.notation.definitionIds),
+          ...lesson.sources.map((id) => {
+            const file = sourceFileById.get(id);
+            return { label: `source ${id}`, digest: file === void 0 ? "missing" : digestOf(file) };
+          })
+        ],
+        { part: lesson.part, chapter: lesson.chapter, numbering: lesson.numbering }
+      )
+    })),
+    // A deck beside its chapter has a version of its own, by its route, and
+    // so has a part's deck; a slides-first lesson's deck is the lesson, above.
+    ...deckModel.decks.flatMap((deck) => {
+      if (deck.chapter === void 0 && deck.part === void 0) return [];
+      const page = deckPages.find((entry) => entry.deck.route === deck.slug);
+      return [
+        {
+          slug: deck.slug,
+          source: pageSourceDigest(
+            [
+              { label: `page ${deck.file}`, digest: digestOf(deck.file) },
+              ...sharedEntryInputs(bundlesByLesson.get(deck.pageId)?.definitionIds ?? []),
+              ...(page === void 0 ? [] : deriveSources(page.notation.body)).map((id) => {
+                const file = sourceFileById.get(id);
+                return { label: `source ${id}`, digest: file === void 0 ? "missing" : digestOf(file) };
+              })
+            ],
+            // A part's deck shows each float it recalls as its chapter
+            // numbers and captions it: those count as the page's too.
+            deck.recalledFrom === void 0 ? {} : { recalls: recalledFloatFacts(deck.recalledFrom) }
+          )
+        }
+      ];
+    }),
+    ...manifestParts.flatMap((part) => {
+      if (!part.overview) return [];
+      const slug = `${part.dir}/index`;
+      const page = pages.find((entry) => entry.slug === slug);
+      return [
+        {
+          slug,
+          source: pageSourceDigest([
+            { label: `page ${part.overview.file}`, digest: digestOf(part.overview.file) },
+            ...sharedEntryInputs(page?.notation.definitionIds ?? [])
+          ])
+        }
+      ];
+    })
+  ];
+  const pageVersionsRecord = nextPageVersions({
+    previous: previousVersions.record,
+    version: knowledge.version,
+    unreleased: knowledge.unreleased.length > 0,
+    pages: trackedPages
+  });
+  const pageVersions = {
+    enabled: trackPageVersions,
+    file: PAGE_VERSIONS_FILE,
+    record: pageVersionsRecord
+  };
+  const sinceOfPage = (slug) => {
+    const entry = pageVersionsRecord.pages[slug];
+    return trackPageVersions && entry !== void 0 ? sinceOf(entry) : knowledge.version;
+  };
   const enginePkg = readEnginePackage();
   const about = {
     engine: {
@@ -891,6 +1156,11 @@ async function compileManifest(courseConfig) {
       version: knowledge.version,
       ...knowledge.latest?.date === void 0 ? {} : { date: knowledge.latest.date },
       notes: knowledge.latest?.notes ?? [],
+      releases: knowledge.entries.map((entry) => ({
+        version: entry.version,
+        ...entry.date === void 0 ? {} : { date: entry.date }
+      })),
+      unreleased: knowledge.unreleased.length > 0,
       contentTree: hashes.contentTree
     },
     authors: courseConfig.about.authors.map((author) => ({
@@ -907,6 +1177,34 @@ async function compileManifest(courseConfig) {
     numbering: numberingSettings,
     blockLabels,
     cards: normalizeCards(courseConfig),
+    sidebarMarks: normalizeSidebarMarks(courseConfig),
+    sidebarEditions: normalizeSidebarEditions(courseConfig),
+    readingMemory: normalizeReadingMemory(courseConfig),
+    appearance: normalizeAppearance(courseConfig),
+    deck: deckSettings,
+    decks: deckModel.decks.map((deck) => {
+      const page = pageInputById.get(deck.pageId);
+      return {
+        ...deck,
+        since: sinceOfPage(deck.slug),
+        notation: lessonNotationBundle(
+          bundlesByLesson.get(deck.pageId),
+          definitionsById,
+          page === void 0 ? [] : lessonNotationResolution(page, definitionsById, availableDefinitionIds),
+          cardsByKey,
+          // A deck shows its lessons' symbols: the derived cards (rule N23)
+          // its chapters' bodies and checks use ship with it, as its bundle
+          // holds the chapters' entries.
+          [
+            ...indexGate.derivedByLesson.get(deck.pageId) ?? [],
+            ...(page?.scopeLessonIds ?? []).flatMap((lessonId) => [
+              ...indexGate.derivedByLesson.get(lessonId) ?? [],
+              ...assessmentDerived.get(lessonId)?.values() ?? []
+            ])
+          ].filter((use, index, all) => all.findIndex((other) => other.key === use.key) === index)
+        )
+      };
+    }),
     about,
     notation: {
       definitions: registry.definitions,
@@ -919,9 +1217,12 @@ async function compileManifest(courseConfig) {
     sources,
     tracks,
     abbreviations,
-    sidebar,
-    parts: manifestParts,
-    lessons,
+    sidebar: sidebarWithFrames,
+    parts: manifestParts.map(
+      ({ overview, ...part }) => overview ? { ...part, overview: { ...overview, since: sinceOfPage(`${part.dir}/index`) } } : part
+    ),
+    lessons: lessons.map((lesson) => ({ ...lesson, since: sinceOfPage(lesson.slug) })),
+    pageVersions,
     pages,
     prereqEdges,
     equations: {
@@ -963,7 +1264,7 @@ async function compileManifest(courseConfig) {
       checks: dropDisabled(checkValidation.diagnostics, off),
       examples: dropDisabled(exampleValidation.diagnostics, off),
       folds: dropDisabled(foldValidation.diagnostics, off),
-      knowledge: dropDisabled(knowledge.diagnostics, off),
+      knowledge: dropDisabled([...knowledge.diagnostics, ...previousVersions.diagnostics], off),
       rawFloats: dropDisabled(rawFloatDiagnostics, off),
       config: rules.diagnostics,
       waivers: waiverDiagnostics