explico 0.13.0 → 0.14.0

package/dist/compiler/decks.d.ts

@@ -0,0 +1,161 @@
+import { DeckFile } from './collections.js';
+import { g as NormalizedDeck } from '../course-config-BLtIdkei.js';
+import { DeckRuleSettings, ChapterFloats } from '../reference/decks-validate.js';
+import { ScopeEntry, MathGateDiagnostic } from '../reference/gate-math.js';
+import '../curriculum/validation.js';
+import '../reference/types.js';
+import '../reference/gate-retired-keys.js';
+import '../rules/catalog.js';
+import '../rules/course-rules.js';
+import '../reference/deck-source.js';
+
+/** One frame of a deck, in the order the deck shows it. */
+interface ManifestDeckFrame {
+    /** 1-based: the generated title frame is 1. */
+    readonly number: number;
+    /**
+     * What the frame shows, as 12 hex digits of a SHA-256 (v35), as rule C5's
+     * hash names a page's content. A reader's record of the frames they saw
+     * keeps it, so a frame that changed since is told from one they never saw
+     * (`session/deck-memory.ts`). An authored frame hashes its source,
+     * notes included, and the chapter's number for each float it recalls; the
+     * title frame its title, course and authors, not its version, which every
+     * release moves; the outcomes frame its outcomes; the references frame the
+     * sources it cites. Another frame's change leaves it as it is.
+     */
+    readonly id: string;
+    /**
+     * `title` and `outcomes` and `references` are generated; `section` is a
+     * `##` divider; `frame` is a `###` frame.
+     */
+    readonly kind: 'title' | 'section' | 'frame' | 'outcomes' | 'references';
+    /** What the reader sees as its title. */
+    readonly title: string;
+    /** The heading's anchor (a section or a frame). */
+    readonly slug?: string;
+    /** A frame's section, by its anchor. */
+    readonly section?: string;
+    /** How many steps the frame shows in: one more than its `<Pause />` marks. */
+    readonly steps: number;
+    /** `### Title [morph]`: the frame morphs from the frame before it. */
+    readonly morph?: true;
+    /** The chapter floats the frame recalls, as written (`eq-range`, `fig-…`). */
+    readonly recalls?: readonly string[];
+    /** The frame carries speaker notes. */
+    readonly notes?: true;
+    /** The notation keys the frame shows for the first time in the deck — its legend line's first-use list. */
+    readonly symbols?: readonly string[];
+    /**
+     * On a part's deck, the chapter the frame's section covers (v36), by its
+     * lesson slug: on the section's divider and on each of its frames.
+     */
+    readonly chapter?: string;
+}
+/** One deck, a lesson's or a part's, as the builder makes it (`ManifestDeck` adds its notation). */
+interface BuiltDeck {
+    /** The lesson the deck is the slide edition of; a part's deck belongs to none (v36). */
+    readonly lessonId?: string;
+    /**
+     * The deck page's id: `<lessonId>.slides`, the lesson's own id when it has
+     * no chapter, or a part's `<part>.slides`.
+     */
+    readonly pageId: string;
+    /** Its route: `<lesson>/slides`, the lesson's own for a slides-first lesson, or a part's `<part>/slides`. */
+    readonly slug: string;
+    readonly file: string;
+    readonly title: string;
+    readonly description: string;
+    /** The lesson's chapter slug, when the deck stands beside one. */
+    readonly chapter?: string;
+    /** A part's deck (`<part>/index.deck.mdx`, v36): the part's directory, `motion`. */
+    readonly part?: string;
+    /**
+     * Each chapter a part's deck covers, in deck order (v36): its lesson slug,
+     * and the number of the frame its section opens on, the divider — the
+     * chapter's address in the deck, `#slide-N`. Empty on a lesson's deck.
+     */
+    readonly covers: readonly {
+        readonly chapter: string;
+        readonly frame: number;
+    }[];
+    /**
+     * A part's deck (v36): the chapter whose float each recall shows, by its
+     * ref (`eq-range` → `projectiles/projectile-range`), which its number
+     * links to. A lesson's deck recalls from its {@link chapter}.
+     */
+    readonly recalledFrom?: Readonly<Record<string, string>>;
+    readonly frames: readonly ManifestDeckFrame[];
+    /** The deck's own labelled equations, numbered (1), (2)… in the deck (rule D8). */
+    readonly equations: readonly {
+        readonly key: string;
+        readonly number: string;
+    }[];
+}
+/** What the builder needs about each deck's lesson. */
+interface DeckLessonFacts {
+    readonly title: string;
+    /** Competencies the lesson teaches; the outcomes frame lists their outcomes. */
+    readonly teaches: readonly string[];
+    /** Those outcomes, in order: what the outcomes frame shows. */
+    readonly outcomes?: readonly string[];
+    /** The chapter's numbered floats, by kind, key → number. Absent: no chapter. */
+    readonly chapterFloats?: ChapterFloats;
+}
+/** One chapter of a part, as a part's deck draws on it. */
+interface DeckChapterFacts {
+    /** Its name in the part's directory, what `[chapter: <name>]` writes: `constant-acceleration`. */
+    readonly name: string;
+    /** Its lesson slug: `motion/constant-acceleration`. */
+    readonly slug: string;
+    /** Competencies it teaches; the outcomes frame lists those of every chapter covered. */
+    readonly teaches: readonly string[];
+    /** Their outcomes, in order. */
+    readonly outcomes: readonly string[];
+    /** What it numbers, which a section of the deck may recall. */
+    readonly floats: ChapterFloats;
+}
+/** What the builder needs about each part that has a deck. */
+interface DeckPartFacts {
+    /** The part's label: the title of its deck when the deck sets none. */
+    readonly label: string;
+    /** The part's chapters, in reading order. */
+    readonly chapters: readonly DeckChapterFacts[];
+    /** The part's lessons that are only slides, by name: a section cannot cover one. */
+    readonly slidesFirst: readonly string[];
+}
+interface BuildDecksInput {
+    readonly decks: readonly DeckFile[];
+    readonly settings: NormalizedDeck;
+    readonly rules: DeckRuleSettings;
+    /** The lesson behind each lesson's deck, by lesson id. */
+    readonly lessons: ReadonlyMap<string, DeckLessonFacts>;
+    /** Each part the course configures that has a deck, by its directory. */
+    readonly parts?: ReadonlyMap<string, DeckPartFacts>;
+    /** What every title frame shows under the deck's title: the course's name and its authors. */
+    readonly course?: {
+        readonly name?: string;
+        readonly authors: readonly string[];
+    };
+    /** The glyph table of each deck's page, by page id (`pageScope`). */
+    readonly scopeOf: (pageId: string) => readonly ScopeEntry[];
+    /** Decorations a deck's page suspends (rule N22), by page id. */
+    readonly suspendedOf?: (pageId: string) => readonly string[];
+    /** A `[[key]]` term's label in a heading, as the deck's page reads it. */
+    readonly labelFor?: (pageId: string, key: string) => string | undefined;
+}
+/**
+ * A frame's id: 12 hex digits of a SHA-256 over its kind and what it shows,
+ * one string each (`ManifestDeckFrame.id`).
+ */
+declare function deckFrameId(kind: ManifestDeckFrame['kind'], shows: readonly string[]): string;
+declare function buildDecks(input: BuildDecksInput): {
+    decks: BuiltDeck[];
+    diagnostics: MathGateDiagnostic[];
+};
+/**
+ * Each labelled display equation of a chapter body, by key: its LaTeX (what
+ * rule D8 compares a deck's equation with).
+ */
+declare function chapterEquationLatex(body: string): Map<string, string>;
+
+export { type BuildDecksInput, type BuiltDeck, type DeckChapterFacts, type DeckLessonFacts, type DeckPartFacts, type ManifestDeckFrame, buildDecks, chapterEquationLatex, deckFrameId };

package/dist/compiler/decks.js

@@ -0,0 +1,235 @@
+import { createHash } from "node:crypto";
+import { readDeckSource } from "../reference/deck-source.js";
+import {
+  chapterNumberOf,
+  resolvePartRecalls,
+  validateDecks
+} from "../reference/decks-validate.js";
+import { mathSpans } from "../reference/gate-math.js";
+import { resolveMathGlyphs } from "../reference/math-glyphs.mjs";
+import { citedSourceIds } from "./lesson-derivation.js";
+const NOTES_BLOCK = /<Notes\s*>[\s\S]*?<\/Notes\s*>/g;
+const TERM = /\[\[\s*([a-z0-9]+(?:[.-][a-z0-9]+)*)\s*\]\]/g;
+const EXPLAIN = /\\explain\s*\{([^{}]+)\}/g;
+const EQ_LABEL = /\\label\{eq:([^{}]+)\}/g;
+function frameKeys(frame, scope, suspended, recalled = /* @__PURE__ */ new Map()) {
+  const text = frame.body.replace(NOTES_BLOCK, (block) => block.replace(/[^\n]/g, " "));
+  const keys = [];
+  const add = (key) => {
+    if (!keys.includes(key)) keys.push(key);
+  };
+  const known = new Set(scope.map((entry) => entry.key));
+  for (const match of text.matchAll(TERM)) {
+    if (known.has(match[1] ?? "")) add(match[1] ?? "");
+  }
+  const latexes = [
+    ...mathSpans(text).map((span) => span.latex),
+    ...frame.recalls.flatMap((recall) => {
+      const latex = recall.ref?.startsWith("eq-") ? recalled.get(recall.ref.slice(3)) : void 0;
+      return latex === void 0 ? [] : [latex];
+    })
+  ];
+  for (const latex of latexes) {
+    for (const match of latex.matchAll(EXPLAIN)) add((match[1] ?? "").trim());
+    try {
+      const result = resolveMathGlyphs(latex.replace(EQ_LABEL, ""), [...scope], { suspended: [...suspended] });
+      for (const binding of result.bindings ?? []) add(binding.key);
+    } catch {
+    }
+  }
+  return keys;
+}
+function ownEquationKeys(source) {
+  const keys = [];
+  for (const frame of source.frames) {
+    for (const math of frame.displayMath) {
+      for (const match of math.latex.matchAll(EQ_LABEL)) {
+        const key = (match[1] ?? "").trim();
+        if (key && !keys.includes(key)) keys.push(key);
+      }
+    }
+  }
+  return keys;
+}
+function deckFrameId(kind, shows) {
+  return createHash("sha256").update(JSON.stringify([kind, ...shows])).digest("hex").slice(0, 12);
+}
+function frameSource(body, frame) {
+  return body.slice(frame.index, frame.end).replace(/\r\n?/gu, "\n").replace(/[ \t]+$/gmu, "").trimEnd();
+}
+function lessonOwner(deck, lesson) {
+  const floats = lesson?.chapterFloats;
+  return {
+    recalled: (ref) => {
+      const number = chapterNumberOf(ref, floats);
+      const latex = ref.startsWith("eq-") ? floats?.equations.get(ref.slice(3))?.latex : void 0;
+      return { ...number === void 0 ? {} : { number }, ...latex === void 0 ? {} : { latex } };
+    },
+    frameChapter: () => void 0,
+    teaches: lesson?.teaches ?? [],
+    outcomes: lesson?.outcomes ?? [],
+    fallbackTitle: lesson?.title ?? deck.lessonId,
+    identity: {
+      lessonId: deck.lessonId,
+      ...deck.chapterPath === void 0 ? {} : { chapter: deck.lessonSlug },
+      covers: []
+    },
+    validation: {
+      hasChapter: deck.chapterPath !== void 0,
+      inPart: deck.inPart,
+      ...floats === void 0 ? {} : { chapter: floats }
+    }
+  };
+}
+function partOwner(deck, part, source) {
+  const facts = {
+    dir: deck.partDir,
+    chapters: (part?.chapters ?? []).map((chapter) => ({ name: chapter.name, slug: chapter.slug, floats: chapter.floats })),
+    slidesFirst: part?.slidesFirst ?? []
+  };
+  const recalls = resolvePartRecalls(source, facts);
+  const covered = new Set(recalls.covered.map((chapter) => chapter.name));
+  const inOrder = (part?.chapters ?? []).filter((chapter) => covered.has(chapter.name));
+  const teaches = [...new Set(inOrder.flatMap((chapter) => chapter.teaches))];
+  return {
+    recalled: (ref) => {
+      const floats = recalls.chapterOf.get(ref)?.floats;
+      const number = chapterNumberOf(ref, floats);
+      const latex = ref.startsWith("eq-") ? floats?.equations.get(ref.slice(3))?.latex : void 0;
+      return { ...number === void 0 ? {} : { number }, ...latex === void 0 ? {} : { latex } };
+    },
+    frameChapter: (position) => recalls.frameChapters[position]?.slug,
+    teaches,
+    outcomes: [...new Set(inOrder.flatMap((chapter) => chapter.outcomes))],
+    fallbackTitle: part?.label ?? deck.partDir,
+    identity: {
+      part: deck.partDir,
+      covers: recalls.covered.map((chapter) => ({ chapter: chapter.slug, frame: chapter.position + 2 })),
+      recalledFrom: Object.fromEntries(
+        [...recalls.chapterOf].sort(([left], [right]) => left.localeCompare(right)).map(([ref, chapter]) => [ref, chapter.slug])
+      )
+    },
+    validation: { hasChapter: false, inPart: part !== void 0, part: facts }
+  };
+}
+function buildDecks(input) {
+  const decks = [];
+  const validation = [];
+  for (const deck of input.decks) {
+    const source = readDeckSource(deck.body, {
+      labelFor: (key) => input.labelFor?.(deck.pageId, key)
+    });
+    const owner = deck.scope === "part" ? partOwner(deck, input.parts?.get(deck.partDir), source) : lessonOwner(deck, input.lessons.get(deck.lessonId));
+    const scope = input.scopeOf(deck.pageId);
+    const suspended = input.suspendedOf?.(deck.pageId) ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    const recalled = new Map(
+      source.frames.flatMap(
+        (frame) => frame.recalls.flatMap((recall) => {
+          if (!recall.ref?.startsWith("eq-")) return [];
+          const latex = owner.recalled(recall.ref).latex;
+          return latex === void 0 ? [] : [[recall.ref.slice(3), latex]];
+        })
+      )
+    );
+    const newSymbols = source.frames.map((frame) => {
+      const fresh = frameKeys(frame, scope, suspended, recalled).filter((key) => !seen.has(key));
+      for (const key of fresh) seen.add(key);
+      return fresh;
+    });
+    validation.push({
+      file: deck.file,
+      pageId: deck.pageId,
+      body: deck.body,
+      bodyLine: deck.bodyLine,
+      data: deck.data,
+      source,
+      ...owner.validation,
+      newSymbols
+    });
+    const title = typeof deck.data.title === "string" && deck.data.title.trim() !== "" ? deck.data.title : owner.fallbackTitle;
+    const frames = [
+      {
+        number: 1,
+        id: deckFrameId("title", [title, input.course?.name ?? "", ...input.course?.authors ?? []]),
+        kind: "title",
+        title,
+        steps: 1
+      }
+    ];
+    source.frames.forEach((frame, index) => {
+      const symbols = newSymbols[index] ?? [];
+      const recalls = frame.recalls.flatMap((recall) => recall.ref === void 0 ? [] : [recall.ref]);
+      const chapter = owner.frameChapter(index);
+      frames.push({
+        number: frames.length + 1,
+        id: deckFrameId(frame.kind, [
+          frameSource(deck.body, frame),
+          ...recalls.map((ref) => `${ref} ${owner.recalled(ref).number ?? "?"}`)
+        ]),
+        kind: frame.kind,
+        title: frame.title,
+        slug: frame.slug,
+        ...frame.section === void 0 ? {} : { section: frame.section },
+        steps: frame.pauses.length + 1,
+        ...frame.morph ? { morph: true } : {},
+        ...recalls.length === 0 ? {} : { recalls },
+        ...frame.notes.length === 0 ? {} : { notes: true },
+        ...symbols.length === 0 ? {} : { symbols },
+        ...chapter === void 0 ? {} : { chapter }
+      });
+    });
+    if (input.settings.outcomesFrame && owner.teaches.length > 0) {
+      frames.push({
+        number: frames.length + 1,
+        id: deckFrameId("outcomes", owner.outcomes),
+        kind: "outcomes",
+        title: "What you can now do",
+        steps: 1
+      });
+    }
+    const cited = [...citedSourceIds(deck.body)].sort();
+    if (cited.length > 0) {
+      frames.push({
+        number: frames.length + 1,
+        id: deckFrameId("references", cited),
+        kind: "references",
+        title: "References",
+        steps: 1
+      });
+    }
+    decks.push({
+      ...owner.identity.lessonId === void 0 ? {} : { lessonId: owner.identity.lessonId },
+      pageId: deck.pageId,
+      slug: deck.route,
+      file: deck.file,
+      title,
+      description: typeof deck.data.description === "string" ? deck.data.description : "",
+      ...owner.identity.chapter === void 0 ? {} : { chapter: owner.identity.chapter },
+      ...owner.identity.part === void 0 ? {} : { part: owner.identity.part },
+      covers: owner.identity.covers,
+      ...owner.identity.recalledFrom === void 0 ? {} : { recalledFrom: owner.identity.recalledFrom },
+      frames,
+      equations: ownEquationKeys(source).map((key, index) => ({ key, number: String(index + 1) }))
+    });
+  }
+  return {
+    decks: decks.sort((left, right) => left.slug.localeCompare(right.slug)),
+    diagnostics: validateDecks(validation, input.rules)
+  };
+}
+function chapterEquationLatex(body) {
+  const latex = /* @__PURE__ */ new Map();
+  for (const span of mathSpans(body)) {
+    for (const match of span.latex.matchAll(EQ_LABEL)) {
+      const key = (match[1] ?? "").trim();
+      if (key && !latex.has(key)) latex.set(key, span.latex);
+    }
+  }
+  return latex;
+}
+export {
+  buildDecks,
+  chapterEquationLatex,
+  deckFrameId
+};

package/dist/compiler/exports/combined-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';
 
 /**

package/dist/compiler/exports/deck-fit.d.ts

@@ -0,0 +1,55 @@
+import { ExportLogger } from './export-chapters.js';
+import { Manifest } from '../manifest.js';
+import './static-tree.js';
+import './html-tree.js';
+import 'parse5';
+import './latex/capture.js';
+import 'node:http';
+import '../../curriculum/validation.js';
+import '../../reference/consistency.js';
+import '../../course-config-BLtIdkei.js';
+import '../../rules/catalog.js';
+import '../../rules/course-rules.js';
+import '../collections.js';
+import '../../reference/types.js';
+import '../../reference/gate-retired-keys.js';
+import '../../reference/lint-ignore.js';
+import '../../reference/equations-validate.js';
+import '../../reference/tables-validate.js';
+import '../../reference/keyed-float-validate.js';
+import '../../reference/figures-validate.js';
+import '../../reference/diagrams-validate.js';
+import '../../reference/examples-validate.js';
+import '../../reference/folds-validate.js';
+import '../../reference/knowledge-checks-validate.js';
+import '../../reference/raw-floats-validate.js';
+import '../../reference/lab-katex-validate.js';
+import '../../reference/gate-math.js';
+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';
+
+interface FrameFitFinding {
+    readonly code: 'frame-overflow';
+    readonly severity: 'error';
+    /** The deck file. */
+    readonly file: string;
+    readonly frame: number;
+    readonly title: string;
+    /** How far past the canvas the content runs, in canvas pixels. */
+    readonly overflow: number;
+    readonly message: string;
+}
+declare function checkFrameFit(outputRoot: string, manifest: Pick<Manifest, 'decks'>, options: {
+    readonly logger: ExportLogger;
+    readonly projectRoot?: string;
+    readonly timeoutMs?: number;
+}): Promise<FrameFitFinding[]>;
+
+export { type FrameFitFinding, checkFrameFit };

package/dist/compiler/exports/deck-fit.js

@@ -0,0 +1,90 @@
+import { parse } from "parse5";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { inferBasePrefix } from "./html-tree.js";
+import { courseChromium, serve } from "./latex/capture.js";
+import { strictMode } from "./export-chapters.js";
+function measureFrames() {
+  const found = [];
+  for (const frame of document.querySelectorAll(".deck .deck-frame")) {
+    const body = frame.querySelector(".deck-frame__body");
+    const canvas = frame.querySelector(".deck-canvas");
+    const over = Math.max(
+      body ? body.scrollHeight - body.clientHeight : 0,
+      body ? body.scrollWidth - body.clientWidth : 0,
+      canvas ? canvas.scrollHeight - canvas.clientHeight : 0
+    );
+    if (over > 1) {
+      found.push({
+        frame: Number(frame.dataset.frame),
+        title: frame.querySelector(".deck-frame__title, .deck-title__title")?.textContent?.trim() ?? "",
+        overflow: Math.round(over)
+      });
+    }
+  }
+  return found;
+}
+async function checkFrameFit(outputRoot, manifest, options) {
+  const decks = manifest.decks ?? [];
+  if (decks.length === 0) return [];
+  const chromium = await courseChromium(options.projectRoot ?? process.cwd());
+  if (!chromium) {
+    const message = "frame-overflow (rule D2): no Chromium from Playwright in this course, so no frame was measured. Install it (`pnpm exec playwright install chromium`) to check that every frame fits its canvas.";
+    if (strictMode()) throw new Error(message);
+    options.logger.warn(message);
+    return [];
+  }
+  const firstPage = await readFile(join(outputRoot, decks[0].slug, "index.html"), "utf8");
+  const base = inferBasePrefix(parse(firstPage));
+  const { origin, server } = await serve(outputRoot, base);
+  const findings = [];
+  let browser;
+  try {
+    browser = await chromium.launch();
+    for (const deck of decks) {
+      const context = await browser.newContext({
+        viewport: { width: 1280, height: 900 },
+        colorScheme: "light",
+        reducedMotion: "reduce",
+        locale: "en-US"
+      });
+      try {
+        const page = await context.newPage();
+        await page.goto(`${origin}${base}${deck.slug}/`, { waitUntil: "load" });
+        await page.evaluate(async (timeout) => {
+          const start = performance.now();
+          while (!(document.querySelector(".deck[data-deck-ready]") && document.fonts.status === "loaded")) {
+            if (performance.now() - start > timeout) break;
+            await new Promise((done) => setTimeout(done, 50));
+          }
+          for (const frame of document.querySelectorAll(".deck .deck-frame")) {
+            frame.scrollIntoView({ block: "center" });
+            await new Promise((done) => requestAnimationFrame(() => setTimeout(done, 30)));
+          }
+          await new Promise((done) => setTimeout(done, 400));
+          window.explicoDeckOverflow?.();
+        }, options.timeoutMs ?? 3e4);
+        for (const { frame, title, overflow } of await page.evaluate(measureFrames)) {
+          findings.push({
+            code: "frame-overflow",
+            severity: "error",
+            file: deck.file,
+            frame,
+            title,
+            overflow,
+            message: `${deck.file}: slide ${frame}${title ? ` \u201C${title}\u201D` : ""} does not fit its canvas \u2014 its content runs ${overflow}px past it (rule D2). Split the frame in two, move its argument into <Notes>, or recall less.`
+          });
+        }
+      } finally {
+        await context.close();
+      }
+    }
+  } finally {
+    await browser?.close();
+    await new Promise((done) => server.close(() => done()));
+  }
+  return findings;
+}
+export {
+  checkFrameFit
+};

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

@@ -1,9 +1,9 @@
-import { ManifestLesson, Manifest } from '../manifest.js';
-import { StaticPage, Block } from './static-tree.js';
+import { ManifestLesson, ManifestDeck, Manifest } from '../manifest.js';
+import { StaticPage, StaticDeck, Block } from './static-tree.js';
 import { CaptureResults } from './latex/capture.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';
@@ -25,9 +25,14 @@ 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 './html-tree.js';
 import 'parse5';
+import 'node:http';
 
 /**
  * What the print exporters (LaTeX, Markdown) share: every chapter's static
@@ -42,8 +47,13 @@ interface ExportLogger {
 declare const consoleLogger: ExportLogger;
 /** In CI or with `EXPLICO_LATEX_STRICT=1`, a missing engine or browser fails the build. */
 declare function strictMode(): boolean;
-/** The content date as seconds since 1970: every export's timestamps. */
-declare function epochOf(manifest: Pick<Manifest, 'about'>): number;
+/**
+ * A document's date as seconds since 1970, for its timestamps: the date of
+ * the release its content last changed in (`since`, rule C5), so a document
+ * keeps its date across the releases that did not touch it; the newest
+ * release's date for a change not yet released, and with no `since`.
+ */
+declare function epochOf(manifest: Pick<Manifest, 'about'>, since?: string | null): number;
 type FigureBlock = Extract<Block, {
     kind: 'figure';
 }>;
@@ -71,13 +81,34 @@ interface PreparedChapter {
     /** The chapter's reading tree, its labs' live caption clauses filled in. */
     readonly page: StaticPage;
 }
+/** A lesson's deck, read from its page (docs/authoring/deck.md). */
+interface PreparedDeck {
+    readonly deck: ManifestDeck;
+    /** Its frames, each lab's live caption clause filled in. */
+    readonly page: StaticDeck;
+    /**
+     * Where each of its figures and diagrams was drawn, by anchor: the deck's
+     * own route, or its chapter's for one it recalls (the chapter's capture is
+     * reused).
+     */
+    readonly figureRoutes: ReadonlyMap<string, string>;
+}
 interface PreparedChapters {
     /** The site's base path, `/` or `/course/`. */
     readonly base: string;
     readonly chapters: readonly PreparedChapter[];
+    /** Each lesson's deck. */
+    readonly decks: readonly PreparedDeck[];
     /** What the capture pass drew, by route and anchor. */
     readonly captures: CaptureResults;
 }
+/** Read one built deck page into its frames. */
+declare function readBuiltDeck(outputRoot: string, route: string): Promise<{
+    html: string;
+    page: StaticDeck;
+}>;
+/** Every block a deck's frames show, notes aside. */
+declare function deckBlocks(page: StaticDeck): Block[];
 /** Read one built page into its reading tree. */
 declare function readBuiltPage(outputRoot: string, slug: string): Promise<{
     html: string;
@@ -95,4 +126,4 @@ declare function prepareChapters(outputRoot: string, manifest: Manifest, options
     readonly projectRoot?: string;
 }): Promise<PreparedChapters>;
 
-export { type ExportLogger, type PreparedChapter, type PreparedChapters, consoleLogger, diagramsOf, epochOf, figuresOf, imageExtension, imageFile, imagesOf, needsCapture, prepareChapters, readBuiltPage, strictMode, withLiveClauses };
+export { type ExportLogger, type PreparedChapter, type PreparedChapters, type PreparedDeck, consoleLogger, deckBlocks, diagramsOf, epochOf, figuresOf, imageExtension, imageFile, imagesOf, needsCapture, prepareChapters, readBuiltDeck, readBuiltPage, strictMode, withLiveClauses };