explico 0.13.0 → 0.14.0

package/dist/compiler/exports/latex-export.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { zip } from "./zip.js";
 import {
   consoleLogger,
+  deckBlocks,
   epochOf,
   figuresOf,
   imageFile,
@@ -14,57 +15,79 @@ import {
   readBuiltPage,
   strictMode
 } from "./export-chapters.js";
+import { latexCacheFromEnvironment } from "./latex/cache.js";
 import { compileLatex, missingCharacters, findLatexEngine } from "./latex/compile.js";
-import { bookSource, chapterFolderName, chapterSource } from "./latex/document.js";
-import { courseFileStem } from "./export-pages.js";
+import { deckNumberingProblems, deckOverflows, deckSource } from "./latex/deck.js";
+import {
+  bookSince,
+  bookSource,
+  chapterFolderName,
+  chapterSource,
+  deckCheckItems
+} from "./latex/document.js";
+import { courseFileStem, deckFileStem, deckOwnerSlug, deckSaveName } from "./export-pages.js";
 import { auxLabels, numberingMismatches, websiteNumbers } from "./latex/numbering.js";
-async function pagePictures(outputRoot, base, page, captured) {
+async function pagePictures(outputRoot, base, page, captures, drawnOn = () => page.route, folder = `figures/${page.route}`) {
   const pictures = /* @__PURE__ */ new Map();
   for (const figure of figuresOf(page.blocks)) {
-    const capturedFigure = captured?.get(figure.anchor);
+    const capturedFigure = captures.get(drawnOn(figure.anchor))?.get(figure.anchor);
     if (capturedFigure) {
-      pictures.set(figure.anchor, {
-        path: `figures/${page.route}/${figure.anchor}.pdf`,
-        content: capturedFigure.pdf
-      });
+      pictures.set(figure.anchor, { path: `${folder}/${figure.anchor}.pdf`, content: capturedFigure.pdf });
       continue;
     }
     if (figure.picture.kind !== "image" || needsCapture(figure)) continue;
     const file = imageFile(outputRoot, base, page.route, figure.picture.src);
     pictures.set(figure.anchor, {
-      path: `figures/${page.route}/${figure.anchor}${extname(file).toLowerCase()}`,
+      path: `${folder}/${figure.anchor}${extname(file).toLowerCase()}`,
       content: await readFile(file)
     });
   }
   return pictures;
 }
-async function mapWithLimit(items, limit, work) {
+function slidesLesson(manifest, lesson) {
+  const byId = new Map(manifest.competencies.map((competency) => [competency.id, competency]));
+  const outcomes = lesson.teaches.flatMap((id) => {
+    const outcome = byId.get(id)?.outcome;
+    return typeof outcome === "string" && outcome.trim() !== "" ? [outcome.trim()] : [];
+  });
+  const base = manifest.lessonExports.canonicalBaseUrl;
+  return { lesson, outcomes, ...base ? { slidesUrl: `${base}${lesson.slug}/` } : {} };
+}
+async function mapWithLimit(items, limit, work, order = items.map((_item, index) => index)) {
   const results = new Array(items.length);
   let next = 0;
   const worker = async () => {
-    while (next < items.length) {
-      const index = next++;
+    while (next < order.length) {
+      const index = order[next++];
       results[index] = await work(items[index]);
     }
   };
-  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, order.length)) }, worker));
   return results;
 }
+function startOrder(jobs) {
+  const rank = { course: 0, part: 1, chapter: 2, deck: 2 };
+  const size = jobs.map(
+    ({ files }) => files.reduce((sum, file) => sum + (typeof file.content === "string" ? Buffer.byteLength(file.content) : file.content.byteLength), 0)
+  );
+  return jobs.map((_job, index) => index).sort((a, b) => rank[jobs[a].kind] - rank[jobs[b].kind] || size[b] - size[a] || a - b);
+}
 async function writeLatexExports(directory, manifest, options = {}) {
   if (!manifest.lessonExports.latex) return;
   const logger = options.logger ?? consoleLogger;
   const strict = strictMode();
   const outputRoot = fileURLToPath(directory);
-  const { base, chapters, captures } = options.prepared ?? await prepareChapters(outputRoot, manifest, { logger, projectRoot: options.projectRoot });
+  const { base, chapters, decks, captures } = options.prepared ?? await prepareChapters(outputRoot, manifest, { logger, projectRoot: options.projectRoot });
   const engine = await findLatexEngine();
   if ("missing" in engine) {
     if (strict) throw new Error(`LaTeX export cannot build PDFs: ${engine.missing}`);
     logger.warn(`LaTeX export: writing the source zips only. ${engine.missing}`);
   }
   const jobs = [];
+  const againstWebsite = (website) => (aux) => numberingMismatches(website, auxLabels(aux));
   const pictures = /* @__PURE__ */ new Map();
   for (const { lesson, page } of chapters) {
-    const chapterPictures = await pagePictures(outputRoot, base, page, captures.get(page.route));
+    const chapterPictures = await pagePictures(outputRoot, base, page, captures);
     pictures.set(lesson.id, chapterPictures);
     jobs.push({
       kind: "chapter",
@@ -72,9 +95,52 @@ async function writeLatexExports(directory, manifest, options = {}) {
       files: chapterSource({ manifest, lesson, page, documentRoutes: /* @__PURE__ */ new Set([page.route]), pictures: chapterPictures }),
       target: lesson.slug,
       folder: chapterFolderName(lesson),
-      website: websiteNumbers(page, `${lesson.part}.${lesson.chapter}`)
+      numbering: againstWebsite(websiteNumbers(page, `${lesson.part}.${lesson.chapter}`)),
+      since: lesson.since
     });
   }
+  const lessonsById = new Map(manifest.lessons.map((lesson) => [lesson.id, lesson]));
+  for (const { deck, page, figureRoutes } of decks) {
+    if (deck.part === void 0 && !lessonsById.has(deck.lessonId ?? "")) continue;
+    const owner = deckOwnerSlug(deck, manifest);
+    const deckPictures = await pagePictures(
+      outputRoot,
+      base,
+      { route: page.route, blocks: deckBlocks(page) },
+      captures,
+      (anchor) => figureRoutes.get(anchor) ?? page.route,
+      "figures"
+    );
+    const { files, frameEnds } = deckSource({ manifest, deck, page, checkItems: deckCheckItems(manifest, deck), pictures: deckPictures });
+    const stem = deckFileStem(owner);
+    const numbering = (aux) => deckNumberingProblems(aux, page.frames.length);
+    const common = { kind: "deck", folder: `${deckSaveName(owner)}-latex`, numbering, since: deck.since };
+    jobs.push({
+      ...common,
+      name: stem,
+      files,
+      target: stem,
+      review: (log) => {
+        const over = deckOverflows(log, frameEnds);
+        if (over.length === 0) return;
+        logger.warn(
+          `LaTeX export: on paper, ${over.length === 1 ? "a slide" : `${over.length} slides`} of ${stem} run${over.length === 1 ? "s" : ""} over the bottom: ${over.map(({ frame, points }) => `slide ${frame} by ${points} pt`).join(", ")}. The web page fits them (rule D2), but the PDF cuts them off. Shorten the slide, or split it.`
+        );
+      }
+    });
+    if (manifest.deck.handoutPdf && manifest.deck.notes !== "off") {
+      const handout = files.find((file) => file.path === "handout.tex");
+      jobs.push({
+        ...common,
+        name: `${stem}-notes`,
+        files: files.flatMap(
+          (file) => file.path === "handout.tex" ? [] : file.path === "main.tex" ? [{ path: "main.tex", content: handout.content }] : [file]
+        ),
+        target: `${stem}-notes`,
+        noZip: true
+      });
+    }
+  }
   const byId = new Map(chapters.map((chapter) => [chapter.lesson.id, chapter]));
   const pageSlugs = new Set(manifest.pages.map((page) => page.slug));
   const parts = [];
@@ -83,9 +149,13 @@ async function writeLatexExports(directory, manifest, options = {}) {
       const chapter = byId.get(id);
       return chapter ? [{ ...chapter, pictures: pictures.get(id) }] : [];
     });
+    const slides = part.lessons.flatMap((id) => {
+      const lesson = lessonsById.get(id);
+      return lesson && !lesson.editions.includes("chapter") ? [slidesLesson(manifest, lesson)] : [];
+    });
     if (partChapters.length === 0) continue;
     const overview = pageSlugs.has(`${part.dir}/index`) ? (await readBuiltPage(outputRoot, `${part.dir}/index`)).page : void 0;
-    parts.push({ part, ...overview ? { overview } : {}, chapters: partChapters });
+    parts.push({ part, ...overview ? { overview } : {}, chapters: partChapters, ...slides.length > 0 ? { slides } : {} });
   }
   const bookNumbers = (bookParts) => new Map(
     bookParts.flatMap(
@@ -106,7 +176,8 @@ async function writeLatexExports(directory, manifest, options = {}) {
       }),
       target: `part/${entry.part.dir}`,
       folder: `${entry.part.dir}-latex`,
-      website: bookNumbers([entry])
+      numbering: againstWebsite(bookNumbers([entry])),
+      since: bookSince([entry])
     });
   }
   if (parts.length > 0) {
@@ -116,33 +187,40 @@ async function writeLatexExports(directory, manifest, options = {}) {
       files: bookSource({ manifest, parts, document: "course", title: course }),
       target: "course",
       folder: `${courseFileStem(manifest)}-latex`,
-      website: bookNumbers(parts)
+      numbering: againstWebsite(bookNumbers(parts)),
+      since: bookSince(parts)
     });
   }
-  const pending = jobs.map((job) => ({
+  const pending = jobs.filter((job) => !job.noZip).map((job) => ({
     target: join(outputRoot, "downloads", `${job.target}-latex.zip`),
     content: zip(job.files.map((file) => ({ path: `${job.folder}/${file.path}`, content: file.content })))
   }));
   const durations = [];
+  const cache = "missing" in engine ? void 0 : await latexCacheFromEnvironment(engine, logger);
+  let reused = 0;
   const started = performance.now();
   if (!("missing" in engine)) {
     const compiled = await mapWithLimit(jobs, availableParallelism(), async (job) => {
       const jobStarted = performance.now();
-      const result = await compileLatex(job.files, engine, { epoch: epochOf(manifest), name: job.name });
-      durations.push({ kind: job.kind, seconds: (performance.now() - jobStarted) / 1e3 });
-      const problems = numberingMismatches(job.website, auxLabels(result.aux));
+      const options2 = { epoch: epochOf(manifest, job.since), name: job.name };
+      const compile = cache ? await cache.compile(job.files, options2) : { result: await compileLatex(job.files, engine, options2), reused: false };
+      const { result } = compile;
+      if (compile.reused) reused += 1;
+      else durations.push({ kind: job.kind, seconds: (performance.now() - jobStarted) / 1e3 });
+      const problems = job.numbering(result.aux);
       if (problems.length > 0) {
         throw new Error(`LaTeX numbers ${job.name} differently from the website:
   ${problems.join("\n  ")}`);
       }
-      const missing = job.kind === "chapter" ? missingCharacters(result.log) : [];
+      job.review?.(result.log);
+      const missing = (job.kind === "chapter" || job.kind === "deck") && !job.noZip ? missingCharacters(result.log) : [];
       if (missing.length > 0) {
         logger.warn(
           `LaTeX export: the PDF of ${job.name} leaves ${missing.length} character(s) blank, which its fonts cannot draw: ${missing.slice(0, 12).join(", ")}${missing.length > 12 ? ", \u2026" : ""}. The web page shows them, the PDF does not. Under LuaLaTeX, install a font that covers them on the build machine (explico.cls looks for CMU Serif, Noto Serif or DejaVu Serif for Greek, Noto CJK or Fandol for Chinese, Japanese and Korean, and Noto Color Emoji for emoji); pdfLaTeX sets none of them. Or write the word in Latin script, or a symbol as math ($\\alpha$).`
         );
       }
       return result.pdf;
-    });
+    }, startOrder(jobs));
     jobs.forEach((job, index) => {
       pending.push({ target: join(outputRoot, "downloads", `${job.target}.pdf`), content: compiled[index] });
     });
@@ -158,12 +236,15 @@ async function writeLatexExports(directory, manifest, options = {}) {
   } finally {
     await Promise.all(temporary.map((file) => rm(file.temporary, { force: true })));
   }
+  const pruned = cache ? await cache.prune() : 0;
   const pdfs = pending.filter((file) => file.target.endsWith(".pdf")).length;
   const seconds = (kind) => durations.filter((entry) => entry.kind === kind).reduce((sum, entry) => sum + entry.seconds, 0);
   logger.info(
-    `LaTeX export: ${chapters.length} chapter(s), ${parts.length} part(s)${parts.length > 0 ? " and the course" : ""}: ${jobs.length} source zip(s)` + (pdfs > 0 ? `, ${pdfs} PDF(s) with ${"name" in engine ? engine.name : ""} in ${wall.toFixed(1)} s on up to ${availableParallelism()} core(s) (compile time: chapters ${seconds("chapter").toFixed(1)} s, parts ${seconds("part").toFixed(1)} s, course ${seconds("course").toFixed(1)} s)` : "") + (captures.size > 0 ? `, figures from ${captures.size} page(s) drawn as vector PDF` : "") + "."
+    `LaTeX export: ${chapters.length} chapter(s), ${decks.length} deck(s), ${parts.length} part(s)${parts.length > 0 ? " and the course" : ""}: ${jobs.filter((job) => !job.noZip).length} source zip(s)` + (pdfs > 0 ? `, ${pdfs} PDF(s) with ${"name" in engine ? engine.name : ""} in ${wall.toFixed(1)} s on up to ${availableParallelism()} core(s) (` + (cache ? `${pdfs - reused} compiled, ${reused} reused from ${cache.directory}${pruned > 0 ? `, ${pruned} unused entr${pruned === 1 ? "y" : "ies"} deleted` : ""}; ` : "") + `compile time: chapters ${seconds("chapter").toFixed(1)} s, decks ${seconds("deck").toFixed(1)} s, parts ${seconds("part").toFixed(1)} s, course ${seconds("course").toFixed(1)} s)` : "") + (captures.size > 0 ? `, figures from ${captures.size} page(s) drawn as vector PDF` : "") + "."
   );
 }
 export {
+  mapWithLimit,
+  startOrder,
   writeLatexExports
 };

package/dist/compiler/exports/markdown/serialize.d.ts

@@ -1,6 +1,6 @@
 import { RootContent } from 'mdast';
 import { CheckItem } from '../latex/serialize.js';
-import { StaticPage, DiagramGeometry } from '../static-tree.js';
+import { StaticPage, StaticDeck, NotationEntry, DiagramGeometry } from '../static-tree.js';
 import '../../../reference/mixed-content.js';
 import '../../../reference/gate-math.js';
 import '../../../reference/types.js';
@@ -32,10 +32,13 @@ interface MarkdownChapterContext {
     readonly pictures: ReadonlyMap<string, string>;
     /** Answers of this page's checks, by assessment id, in authored order. */
     readonly checkItems: ReadonlyMap<string, readonly CheckItem[]>;
-    /** Course title, version and the page's live URL, for the line under its title. */
+    /**
+     * The line under the title: the course, the version the page's content is
+     * at (`versionPhrase`, rule C5) and its live URL.
+     */
     readonly source?: {
         readonly course: string;
-        readonly version?: string;
+        readonly since?: string;
         readonly url?: string;
     };
 }
@@ -45,7 +48,24 @@ declare function diagramEdges(geometry: DiagramGeometry): [number, number][];
 declare function serializeMarkdownPage(context: MarkdownChapterContext, options?: {
     readonly number?: string;
 }): string;
+/** The slide sizes Marp's built-in themes have. */
+type MarpSize = '16:9' | '4:3';
+interface MarpDeckContext extends Omit<MarkdownChapterContext, 'page'> {
+    readonly deck: StaticDeck;
+    /** The symbols its frames use, by first use: its closing notation slide. */
+    readonly symbols: readonly NotationEntry[];
+    readonly size: MarpSize;
+}
+/**
+ * A deck in Marp's Markdown (decision D10): front matter that turns Marp on,
+ * one slide per frame between `---` lines, numbered as the deck is, each
+ * frame's notes and its check's answers as an HTML comment (Marp's speaker
+ * notes), and a closing slide of the symbols the frames use. A step shows
+ * its frame's final state, as the handout does. The file reads as plain
+ * Markdown too; Marp, its VS Code extension and Deckset present it.
+ */
+declare function serializeMarpDeck(context: MarpDeckContext): string;
 /** Markdown of a few blocks of mdast, written the same way (for a download's `index.md`). */
 declare function serializeMarkdownNodes(children: RootContent[]): string;
 
-export { type MarkdownChapterContext, diagramEdges, serializeMarkdownNodes, serializeMarkdownPage };
+export { type MarkdownChapterContext, type MarpDeckContext, type MarpSize, diagramEdges, serializeMarkdownNodes, serializeMarkdownPage, serializeMarpDeck };

package/dist/compiler/exports/markdown/serialize.js

@@ -1,7 +1,7 @@
 import { gfmTableToMarkdown } from "mdast-util-gfm-table";
 import { mathToMarkdown } from "mdast-util-math";
 import { toMarkdown } from "mdast-util-to-markdown";
-import { captionTitle } from "../../../components/float-name.js";
+import { captionTitle } from "../../../reference/float-name.js";
 import { stripNotationMarkers } from "../../../reference/math-glyphs.mjs";
 const text = (value) => ({ type: "text", value });
 const html = (value) => ({ type: "html", value });
@@ -428,16 +428,19 @@ class MarkdownWriter {
       }
     ];
   }
-  answers(checks) {
+  /**
+   * The answers to `checks`: under their own heading at a page's end, or
+   * bare (`inline`), as a deck's speaker notes give them.
+   */
+  answers(checks, inline = false) {
     if (checks.length === 0) return [];
     return [
-      { type: "heading", depth: 2, children: [anchor("answers"), text("Answers to the knowledge checks")] },
+      ...inline ? [] : [{ type: "heading", depth: 2, children: [anchor("answers"), text("Answers to the knowledge checks")] }],
       ...checks.flatMap((check) => {
         const items = this.context.checkItems.get(check.assessmentId) ?? [];
+        const name = text(`Knowledge check ${check.number}`);
         return [
-          paragraph([
-            strong([link(`#${check.anchor}`, [text(`Knowledge check ${check.number}`)]), text(": "), ...this.inlines(check.title)])
-          ]),
+          paragraph([strong([inline ? name : link(`#${check.anchor}`, [name]), text(": "), ...this.inlines(check.title)])]),
           {
             type: "list",
             ordered: true,
@@ -501,7 +504,7 @@ function serializeMarkdownPage(context, options = {}) {
   const sourceLine = source ? [
     text("From "),
     emphasis([text(source.course)]),
-    ...source.version ? [text(`, version ${source.version}`)] : [],
+    ...source.since ? [text(`, ${source.since}`)] : [],
     text("."),
     ...source.url ? [text(" Interactive version: "), link(source.url, [text(source.url)]), text(".")] : []
   ] : [];
@@ -517,11 +520,85 @@ function serializeMarkdownPage(context, options = {}) {
     ...writer.answers(checksOf(page.blocks))
   ]);
 }
+function serializeMarpDeck(context) {
+  const { deck, source } = context;
+  const page = {
+    slug: deck.slug,
+    route: deck.route,
+    title: deck.title,
+    blocks: [],
+    notation: deck.notation,
+    notationRemarks: []
+  };
+  const writer = new MarkdownWriter({ ...context, page });
+  const heading = (depth, children) => ({ type: "heading", depth, children });
+  const lead = { type: "html", value: "<!-- _class: lead -->" };
+  const notes = (blocks) => blocks.length === 0 ? [] : [{ type: "html", value: `<!--
+${serializeNodes(blocks).trim().replace(/--/gu, "- -")}
+-->` }];
+  const slides = deck.frames.map((frame) => {
+    const title = writer.inlines(frame.title);
+    if (frame.kind === "title") {
+      return [
+        lead,
+        heading(1, title),
+        ...source ? [
+          paragraph([
+            emphasis([text(source.course)]),
+            ...source.since ? [text(`, ${source.since}`)] : [],
+            text("."),
+            ...source.url ? [text(" Interactive version: "), link(source.url, [text(source.url)]), text(".")] : []
+          ])
+        ] : []
+      ];
+    }
+    if (frame.kind === "section") return [lead, heading(1, title)];
+    const blocks = frame.segments.flatMap((segment) => segment.blocks);
+    const legend = frame.legend.filter((item) => item.tex);
+    return [
+      heading(2, title),
+      ...writer.blocks(blocks),
+      ...legend.length > 0 ? [
+        paragraph([
+          emphasis(
+            legend.flatMap((item, index) => [
+              ...index > 0 ? [text(" \xB7 ")] : [],
+              { type: "inlineMath", value: plainTex(item.tex) },
+              text(" "),
+              ...writer.inlines(item.label)
+            ])
+          )
+        ])
+      ] : [],
+      ...notes([...writer.blocks(frame.notes), ...writer.answers(checksOf(blocks), true)])
+    ];
+  });
+  if (context.symbols.length > 0) {
+    slides.push([heading(2, [text("Notation")]), ...writer.notation(context.symbols, []).slice(1)]);
+  }
+  const body = serializeNodes(
+    slides.flatMap((slide, index) => [...index > 0 ? [{ type: "thematicBreak" }] : [], ...slide])
+  );
+  const frontMatter = [
+    "---",
+    "marp: true",
+    `title: ${JSON.stringify(deck.title)}`,
+    `size: ${context.size}`,
+    "paginate: true",
+    "math: katex",
+    "---",
+    ""
+  ].join("\n");
+  const markdown = body.replace(/<a id="[^"]*"><\/a> ?/gu, "").replace(/(?<!!)\[([^\]]*)\]\(#[^)]*\)/gu, "$1").replace(/\n{3,}/gu, "\n\n");
+  return `${frontMatter}
+${markdown}`;
+}
 function serializeMarkdownNodes(children) {
   return serializeNodes(children);
 }
 export {
   diagramEdges,
   serializeMarkdownNodes,
-  serializeMarkdownPage
+  serializeMarkdownPage,
+  serializeMarpDeck
 };

package/dist/compiler/exports/markdown-export.d.ts

@@ -2,7 +2,7 @@ import { Manifest } from '../manifest.js';
 import { ExportLogger, PreparedChapters } from './export-chapters.js';
 import '../../curriculum/validation.js';
 import '../../reference/consistency.js';
-import '../../course-config-rRtME5UV.js';
+import '../../course-config-BLtIdkei.js';
 import '../../rules/catalog.js';
 import '../../rules/course-rules.js';
 import '../collections.js';
@@ -24,11 +24,16 @@ import '../../reference/mixed-content.js';
 import '../../reference/gloss.js';
 import '../../rules/waivers.js';
 import '../knowledge-version.js';
+import '../page-versions.js';
+import '../decks.js';
+import '../../reference/decks-validate.js';
+import '../../reference/deck-source.js';
 import '../lesson-derivation.js';
 import './static-tree.js';
 import './html-tree.js';
 import 'parse5';
 import './latex/capture.js';
+import 'node:http';
 
 declare function writeMarkdownExports(directory: URL, manifest: Manifest, options?: {
     readonly logger?: ExportLogger;

package/dist/compiler/exports/markdown-export.js

@@ -1,9 +1,11 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { courseFileStem } from "./export-pages.js";
+import { newestSince, versionPhrase } from "../page-versions.js";
+import { courseFileStem, deckFileStem, deckOwnerSlug, deckSaveName } from "./export-pages.js";
 import {
   consoleLogger,
+  deckBlocks,
   diagramsOf,
   figuresOf,
   imageExtension,
@@ -13,8 +15,9 @@ import {
   prepareChapters,
   readBuiltPage
 } from "./export-chapters.js";
-import { checkItems } from "./latex/document.js";
-import { serializeMarkdownNodes, serializeMarkdownPage } from "./markdown/serialize.js";
+import { deckSymbols } from "./latex/deck.js";
+import { checkItems, deckCheckItems } from "./latex/document.js";
+import { serializeMarkdownNodes, serializeMarkdownPage, serializeMarpDeck } from "./markdown/serialize.js";
 import { zip } from "./zip.js";
 async function pagePictures(outputRoot, base, page, captured, assetDir) {
   const pictures = /* @__PURE__ */ new Map();
@@ -57,15 +60,19 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
   if (!manifest.lessonExports.markdown) return;
   const logger = options.logger ?? consoleLogger;
   const outputRoot = fileURLToPath(directory);
-  const { base, chapters, captures } = options.prepared ?? await prepareChapters(outputRoot, manifest, { logger, projectRoot: options.projectRoot });
+  const { base, chapters, decks, captures } = options.prepared ?? await prepareChapters(outputRoot, manifest, { logger, projectRoot: options.projectRoot });
   const canonicalBaseUrl = manifest.lessonExports.canonicalBaseUrl;
   const course = manifest.about.material.name;
-  const version = manifest.about.knowledge.version;
-  const source = (route) => ({
+  const current = manifest.about.knowledge.version;
+  const source = (route, since) => ({
     course,
-    version,
+    since: versionPhrase(since, current),
     ...canonicalBaseUrl ? { url: `${canonicalBaseUrl}${route ? `${route}/` : ""}` } : {}
   });
+  const partSince = (entry) => newestSince([
+    ...entry.part.overview ? [entry.part.overview.since] : [],
+    ...entry.chapters.map(({ lesson }) => lesson.since)
+  ]);
   const chapterFiles = async (chapter, file, assetDir, documentFiles) => {
     const { lesson, page } = chapter;
     const pictures = await pagePictures(outputRoot, base, page, captures.get(page.route), assetDir);
@@ -76,7 +83,7 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
         ...canonicalBaseUrl ? { canonicalBaseUrl } : {},
         pictures: new Map([...pictures].map(([key, picture]) => [key, picture.path])),
         checkItems: checkItems(manifest, lesson),
-        source: source(page.route)
+        source: source(page.route, lesson.since)
       },
       { number: `${lesson.part}.${lesson.chapter}` }
     );
@@ -101,6 +108,38 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
       await chapterFiles(chapter, "lesson.md", "assets", /* @__PURE__ */ new Map([[chapter.page.route, "lesson.md"]]))
     );
   }
+  for (const { deck, page, figureRoutes } of decks) {
+    if (deck.part === void 0 && !manifest.lessons.some((entry) => entry.id === deck.lessonId)) continue;
+    const owner = deckOwnerSlug(deck, manifest);
+    const captured = /* @__PURE__ */ new Map();
+    for (const [anchor, route] of figureRoutes) {
+      const figure = captures.get(route)?.get(anchor);
+      if (figure) captured.set(anchor, figure);
+    }
+    const blocks = [...deckBlocks(page), ...page.frames.flatMap((frame) => frame.notes)];
+    const pictures = await pagePictures(
+      outputRoot,
+      base,
+      { slug: page.slug, route: page.route, title: page.title, blocks, notation: [], notationRemarks: [] },
+      captured,
+      "assets"
+    );
+    const items = deckCheckItems(manifest, deck);
+    const markdown = serializeMarpDeck({
+      deck: page,
+      documentFiles: /* @__PURE__ */ new Map([[page.route, ""]]),
+      ...canonicalBaseUrl ? { canonicalBaseUrl } : {},
+      pictures: new Map([...pictures].map(([key, picture]) => [key, picture.path])),
+      checkItems: items,
+      source: source(page.route, deck.since),
+      symbols: deckSymbols({ deck: page, documentRoutes: /* @__PURE__ */ new Set([page.route]), pictures: /* @__PURE__ */ new Map(), checkItems: items }),
+      size: manifest.deck.aspectRatio === "4:3" ? "4:3" : "16:9"
+    });
+    pack(`${deckFileStem(owner)}-markdown.zip`, `${deckSaveName(owner)}-markdown`, [
+      { path: "slides.md", content: markdown },
+      ...[...pictures.values()].map((picture) => ({ path: picture.path, content: picture.content }))
+    ]);
+  }
   const byId = new Map(chapters.map((chapter) => [chapter.lesson.id, chapter]));
   const pageSlugs = new Set(manifest.pages.map((page) => page.slug));
   const parts = manifest.parts.map((part) => ({
@@ -121,7 +160,7 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
         ...canonicalBaseUrl ? { canonicalBaseUrl } : {},
         pictures: new Map([...pictures].map(([key, picture]) => [key, picture.path])),
         checkItems: /* @__PURE__ */ new Map(),
-        source: source(page.route)
+        source: source(page.route, partSince(entry))
       },
       { number: `Part ${entry.part.ordinal}:` }
     );
@@ -186,7 +225,7 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
       {
         type: "paragraph",
         children: [
-          { type: "text", value: `Content version ${version}.` },
+          { type: "text", value: `Content ${versionPhrase(newestSince(parts.map(partSince)), current)}.` },
           ...canonicalBaseUrl ? [
             { type: "text", value: " Interactive version: " },
             { type: "link", url: canonicalBaseUrl, children: [{ type: "text", value: canonicalBaseUrl }] },
@@ -232,7 +271,7 @@ async function writeMarkdownExports(directory, manifest, options = {}) {
     await Promise.all(pending.map((file) => rm(`${file.target}.tmp-${process.pid}`, { force: true })));
   }
   logger.info(
-    `Markdown export: ${chapters.length} chapter(s), ${parts.length} part(s)` + (parts.length > 0 ? " and the course" : "") + "."
+    `Markdown export: ${chapters.length} chapter(s), ${decks.length} deck(s), ${parts.length} part(s)` + (parts.length > 0 ? " and the course" : "") + "."
   );
 }
 export {

package/dist/compiler/exports/standalone-html.d.ts

@@ -1,7 +1,7 @@
 import { Manifest } from '../manifest.js';
 import '../../curriculum/validation.js';
 import '../../reference/consistency.js';
-import '../../course-config-rRtME5UV.js';
+import '../../course-config-BLtIdkei.js';
 import '../../rules/catalog.js';
 import '../../rules/course-rules.js';
 import '../collections.js';
@@ -23,6 +23,10 @@ import '../../reference/mixed-content.js';
 import '../../reference/gloss.js';
 import '../../rules/waivers.js';
 import '../knowledge-version.js';
+import '../page-versions.js';
+import '../decks.js';
+import '../../reference/decks-validate.js';
+import '../../reference/deck-source.js';
 import '../lesson-derivation.js';
 
 /** Inputs for producing one standalone page from Astro's final HTML. */
@@ -39,10 +43,11 @@ declare function buildStandaloneLessonHtml(input: StandaloneLessonInput): Promis
 /** Astro's built HTML file of a docs slug. */
 declare function pageSourceFile(outputRoot: string, slug: string): Promise<string>;
 /**
- * Emit the opt-in standalone HTML artifact of every chapter
- * (`standalonePageSlugs`) from Astro's completed static output, at
- * `downloads/<docs slug>.html`. A page that is not a chapter is in its
- * part's and the course's files (`combined-html.ts`).
+ * Emit the opt-in standalone HTML artifact of every chapter and deck
+ * (`standaloneDownloads`) from Astro's completed static output, at
+ * `downloads/<docs slug>.html` and `downloads/<lesson>-slides.html`. A page
+ * that is not a chapter is in its part's and the course's files
+ * (`combined-html.ts`).
  */
 declare function writeStandaloneLessonExports(directory: URL, manifest: Manifest): Promise<void>;
 

package/dist/compiler/exports/standalone-html.js

@@ -10,7 +10,7 @@ import { Buffer } from "node:buffer";
 import { dirname, extname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse, serialize } from "parse5";
-import { exportPageRoute, standalonePageSlugs } from "./export-pages.js";
+import { exportPageRoute, standaloneDownloads } from "./export-pages.js";
 import {
   attribute,
   elements,
@@ -760,9 +760,9 @@ async function writeStandaloneLessonExports(directory, manifest) {
   if (!manifest.lessonExports.standaloneHtml) return;
   const outputRoot = fileURLToPath(directory);
   const pending = [];
-  for (const slug of standalonePageSlugs(manifest)) {
+  for (const { slug, download } of standaloneDownloads(manifest)) {
     const sourceFile = await pageSourceFile(outputRoot, slug);
-    const target = join(outputRoot, "downloads", `${slug}.html`);
+    const target = join(outputRoot, "downloads", `${download}.html`);
     pending.push({
       target,
       temporary: `${target}.tmp-${process.pid}`,