explico 0.13.1 → 0.14.0

package/dist/compiler/exports/latex/deck.d.ts

@@ -0,0 +1,92 @@
+import { Manifest, ManifestDeck } from '../../manifest.js';
+import { StaticDeck, NotationEntry } from '../static-tree.js';
+import { ChapterContext } from './serialize.js';
+import { SourceFile } from './document.js';
+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';
+import '../html-tree.js';
+import 'parse5';
+
+/** `beamerthemeexplico.sty`, read next to this module. */
+declare function deckTheme(): string;
+/**
+ * The notation keys a deck's LaTeX names, in order of first use: in a
+ * formula (`\explain{key}{…}`) or in prose (`\ExplicoTerm{key}{…}`).
+ */
+declare function deckNotationKeys(tex: string): string[];
+/**
+ * The symbols a deck's frames use, in order of first use, from its page's
+ * notation list: its appendix in every download.
+ */
+declare function deckSymbols(context: Omit<ChapterContext, 'page'> & {
+    readonly deck: StaticDeck;
+}): NotationEntry[];
+interface DeckSerialization {
+    /** `deck.tex`: every frame, in order. */
+    readonly tex: string;
+    /** The line of `deck.tex` each frame ends on, by frame number: a paper overflow names its frame by it. */
+    readonly frameEnds: ReadonlyMap<number, number>;
+}
+/**
+ * The frames of a deck in beamer, then the notation appendix of the symbols
+ * they use (`appendix`, each linked from its uses through `notationTargets`).
+ */
+declare function serializeDeck(context: Omit<ChapterContext, 'page'> & {
+    readonly deck: StaticDeck;
+    readonly appendix?: readonly NotationEntry[];
+}): DeckSerialization;
+interface DeckSourceInput {
+    readonly manifest: Manifest;
+    readonly deck: ManifestDeck;
+    readonly page: StaticDeck;
+    readonly checkItems: ChapterContext['checkItems'];
+    readonly pictures: ReadonlyMap<string, {
+        readonly path: string;
+        readonly content: Uint8Array;
+    }>;
+    readonly scripts?: boolean;
+}
+/** A deck's LaTeX folder, and where each of its frames ends in `deck.tex`. */
+declare function deckSource(input: DeckSourceInput): {
+    files: SourceFile[];
+    frameEnds: ReadonlyMap<number, number>;
+};
+/**
+ * The frames LaTeX numbered differently from the deck page: each frame's
+ * `\label{frame:N}` must carry frame number N.
+ */
+declare function deckNumberingProblems(aux: string, frames: number): string[];
+/** The frames a beamer log says run over their slide, by `deck.tex` line: `{ frame, points }`. */
+declare function deckOverflows(log: string, frameEnds: ReadonlyMap<number, number>): {
+    frame: number;
+    points: number;
+}[];
+
+export { type DeckSerialization, type DeckSourceInput, deckNotationKeys, deckNumberingProblems, deckOverflows, deckSource, deckSymbols, deckTheme, serializeDeck };

package/dist/compiler/exports/latex/deck.js

@@ -0,0 +1,349 @@
+import { readFileSync } from "node:fs";
+import { escapeText, ChapterWriter, labelOf, linkExplains } from "./serialize.js";
+import { versionPhrase } from "../../page-versions.js";
+import { explicoCommon, needsScripts, trailerId } from "./document.js";
+function deckTheme() {
+  return readFileSync(new URL("./beamerthemeexplico.sty", import.meta.url), "utf8");
+}
+const ASPECT = { "16:9": "169", "16:10": "1610", "4:3": "43" };
+function deckPage(deck) {
+  return {
+    slug: deck.slug,
+    route: deck.route,
+    title: deck.title,
+    blocks: deck.frames.flatMap((frame) => [...frame.segments.flatMap((segment) => segment.blocks), ...frame.notes]),
+    notation: [],
+    notationRemarks: []
+  };
+}
+class DeckWriter extends ChapterWriter {
+  inline(inline) {
+    if (inline.kind === "cite") return `[${escapeText(inline.number)}]`;
+    return super.inline(inline);
+  }
+  /** A float's caption on a frame: its number (the chapter's, when recalled), its short and long caption. */
+  deckCaption(kind, block, extra = []) {
+    const number = block.number ? `${kind}~${escapeText(block.number)}` : "";
+    const short = block.short?.trim() ? escapeText(block.short.trim().replace(/\.$/u, "")) : "";
+    const long = [this.plain(block.caption), this.plain(extra)].filter(Boolean).join(" ");
+    return `\\ExplicoDeckCaption{${number}}{${short}}{${long}}`;
+  }
+  block(block, inBox = false) {
+    switch (block.kind) {
+      case "heading":
+        return `\\par\\textbf{${this.plain(block.children)}}\\par`;
+      case "equation":
+        return `\\begin{equation*}
+${this.math(block.tex)}
+\\tag{${escapeText(block.number)}}
+\\end{equation*}`;
+      case "list": {
+        const environment = block.ordered ? "enumerate" : "itemize";
+        const items = block.items.map((item, index) => {
+          const step = block.itemSteps?.[index] ?? 1;
+          return `\\item${step > 1 ? `<${step}->` : ""} ${this.blocks(item, inBox)}`;
+        });
+        return `\\begin{${environment}}
+${items.join("\n")}
+\\end{${environment}}`;
+      }
+      case "figure": {
+        const alt = block.alt ?? [block.short, ...block.caption.map((inline) => "value" in inline ? inline.value : "")].filter(Boolean).join(" ");
+        const picture = this.picture(block.anchor, block.picture, alt).replace("max height=0.6\\textheight", "max height=0.62\\textheight");
+        return `\\begin{center}
+${picture}
+${this.deckCaption("Figure", block, block.live)}
+\\end{center}`;
+      }
+      case "diagram":
+        return [
+          "\\begin{center}",
+          "\\begin{adjustbox}{max width=\\linewidth,max height=0.62\\textheight}",
+          this.unlinkedWhile(() => this.picture(block.anchor, { kind: "diagram", geometry: block.geometry }, "")),
+          "\\end{adjustbox}",
+          this.deckCaption("Diagram", block),
+          "\\end{center}"
+        ].join("\n");
+      case "table": {
+        const tabular = this.table({ ...block, number: "" }, true);
+        return `\\begin{center}
+${this.deckCaption("Table", block)}
+\\smallskip
+${tabular}
+\\end{center}`;
+      }
+      case "memo":
+        return [`\\begin{block}{${this.plain(block.title)}}`, this.blocks(block.children, true), "\\end{block}"].join("\n");
+      case "note":
+        return [`\\begin{block}{${escapeText(block.title)}}`, this.blocks(block.children, true), "\\end{block}"].join("\n");
+      case "aside": {
+        const environment = block.variant === "caution" || block.variant === "danger" ? "alertblock" : "block";
+        return [`\\begin{${environment}}{${this.plain(block.title)}}`, this.blocks(block.children, true), `\\end{${environment}}`].join("\n");
+      }
+      case "examples":
+        return block.items.map((item) => [`\\begin{block}{${this.plain(item.title)}}`, this.blocks(item.children, true), "\\end{block}"].join("\n")).join("\n");
+      case "check": {
+        const items = this.context.checkItems.get(block.assessmentId) ?? [];
+        const questions = items.map((item) => {
+          const options = item.type === "single-choice" && item.options && item.options.length > 0 ? `
+\\begin{enumerate}
+${item.options.map((option) => `\\item[(${String.fromCharCode(97 + item.options.indexOf(option))})] ${this.optionLabel(option)}`).join("\n")}
+\\end{enumerate}` : "";
+          return `\\item ${this.segments(item.promptSegments)}${options}`;
+        });
+        return [
+          `\\par{\\usebeamercolor[fg]{structure}\\textbf{Knowledge check ${escapeText(block.number)}}}\\enspace ${this.plain(block.title)}\\par`,
+          ...questions.length > 0 ? ["\\begin{enumerate}", ...questions, "\\end{enumerate}"] : []
+        ].join("\n");
+      }
+      default:
+        return super.block(block, inBox);
+    }
+  }
+  /** A check's answers, for the frame's notes. */
+  checkAnswers(block) {
+    const items = this.context.checkItems.get(block.assessmentId) ?? [];
+    return items.map((item) => {
+      if (item.type === "single-choice" && item.options) {
+        const index = item.options.findIndex((option) => option.id === item.correctOptionId);
+        const answer = index === -1 ? "" : `(${String.fromCharCode(97 + index)}) ${this.optionLabel(item.options[index])}. `;
+        return `Answer: ${answer}${this.segments(item.explanationSegments)}`;
+      }
+      if (item.type === "numeric" && item.answer) {
+        return `Answer: $${item.answer.value}$ (within $\\pm${item.answer.tolerance}$). ${this.segments(item.explanationSegments)}`;
+      }
+      return this.segments(item.explanationSegments);
+    }).join("\\par ");
+  }
+  frameTitle(frame) {
+    return this.plain(frame.title);
+  }
+  /** A legend line's symbol, linked to its appendix entry. */
+  legendSymbol(tex) {
+    return this.math(tex);
+  }
+  /**
+   * The notation appendix: each symbol the deck uses, by first use, with its
+   * name, what it is, its units and its defining formula, as the chapter's
+   * notation lists it. It breaks over as many frames as it needs.
+   */
+  notationFrames(entries) {
+    if (entries.length === 0) return "";
+    const targets = new Set(entries.map((entry) => entry.key));
+    const items = entries.map((entry) => {
+      const formula = entry.formulaTex ? linkExplains(entry.formulaTex, (named) => named !== entry.key && targets.has(named) ? labelOf("notation", named) : void 0) : void 0;
+      const parts = [
+        `\\textbf{${this.inlines(entry.label)}}.`,
+        this.inlines(entry.summary),
+        ...entry.units ? [`\\emph{Units:} ${this.inlines(entry.units)}.`] : [],
+        ...formula ? [`$${formula}$`] : []
+      ];
+      return `\\item[{${entry.symbolTex ? `$${entry.symbolTex}$` : ""}}]\\hypertarget{${labelOf("notation", entry.key)}}{}${parts.join(" ")}`;
+    });
+    return [
+      "\\appendix",
+      "\\section{Notation}",
+      "\\begin{frame}[allowframebreaks,t]{Notation}",
+      "\\small",
+      "\\begin{description}",
+      ...items,
+      "\\end{description}",
+      "\\end{frame}"
+    ].join("\n");
+  }
+}
+function deckNotationKeys(tex) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const match of tex.matchAll(/\\(?:explain|ExplicoTerm)\{([^{}]+)\}\{/gu)) keys.add(match[1]);
+  return [...keys];
+}
+function deckSymbols(context) {
+  const byKey = new Map(context.deck.notation.map((entry) => [entry.key, entry]));
+  return deckNotationKeys(serializeDeck(context).tex).flatMap((key) => {
+    const entry = byKey.get(key);
+    return entry ? [entry] : [];
+  });
+}
+function checksOf(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.kind === "check") out.push(block);
+    if ("children" in block && Array.isArray(block.children) && block.kind !== "paragraph" && block.kind !== "heading") {
+      out.push(...checksOf(block.children));
+    }
+  }
+  return out;
+}
+function hasCode(blocks) {
+  return blocks.some(
+    (block) => block.kind === "code" || "children" in block && Array.isArray(block.children) && block.kind !== "paragraph" && block.kind !== "heading" && hasCode(block.children)
+  );
+}
+function serializeDeck(context) {
+  const writer = new DeckWriter({ ...context, page: deckPage(context.deck) });
+  const lines = [];
+  const frameEnds = /* @__PURE__ */ new Map();
+  const push = (text) => lines.push(...text.split("\n"));
+  push(`\\ExplicoDeckFrames{${context.deck.frames.length}}`);
+  lines.push("");
+  for (const frame of context.deck.frames) {
+    const label = `\\label{frame:${frame.number}}`;
+    if (frame.kind === "title") {
+      push(`\\begin{frame}[plain]${label}
+\\titlepage
+\\end{frame}`);
+    } else if (frame.kind === "section") {
+      push(`\\section{${writer.frameTitle(frame)}}
+\\begin{frame}${label}
+\\ExplicoSectionPage
+\\end{frame}`);
+    } else {
+      const blocks = frame.segments.flatMap((segment) => segment.blocks);
+      const options = hasCode(blocks) ? "[fragile]" : "";
+      const body = frame.segments.map((segment) => {
+        const content = writer.blocks(segment.blocks);
+        return segment.step > 1 ? `\\begin{uncoverenv}<${segment.step}->
+${content}
+\\end{uncoverenv}` : content;
+      });
+      const legend = frame.legend.filter((item) => item.tex);
+      const answers = checksOf(blocks).map((check) => writer.checkAnswers(check)).filter(Boolean);
+      const notes = [writer.blocks(frame.notes), ...answers].filter((text) => text.trim().length > 0);
+      push(
+        [
+          `\\begin{frame}${options}{${writer.frameTitle(frame)}}${label}`,
+          ...body,
+          ...legend.length > 0 ? [`\\ExplicoLegend{${legend.map((item) => `$${writer.legendSymbol(item.tex)}$~${escapeText(item.label.map((inline) => "value" in inline ? inline.value : "").join(""))}`).join("\\quad ")}}`] : [],
+          ...notes.length > 0 ? [`\\note{${notes.join("\n\n")}}`] : [],
+          "\\end{frame}"
+        ].join("\n")
+      );
+    }
+    frameEnds.set(frame.number, lines.length);
+    lines.push("");
+  }
+  const appendix = writer.notationFrames(context.appendix ?? []);
+  if (appendix) push(`${appendix}
+`);
+  return { tex: `${lines.join("\n")}
+`, frameEnds };
+}
+const LATEXMKRC = [
+  "# LuaLaTeX by default; `latexmk -pdf` uses pdfLaTeX instead.",
+  "$pdf_mode = 4;",
+  "$postscript_mode = $dvi_mode = 0;",
+  "# luaotfload rewrites its font caches as fonts are looked up; they are not",
+  "# this document's sources, so a rewrite is no reason to run again.",
+  "$hash_calc_ignore_pattern{'luc'} = '^';",
+  ""
+].join("\n");
+function deckMain(manifest, deck, handout, scripts) {
+  const ratio = ASPECT[manifest.deck?.aspectRatio ?? "16:9"] ?? "169";
+  const course = manifest.about.material.name;
+  const authors = (manifest.about.authors ?? []).map((author) => author.name).filter(Boolean).join(", ");
+  const version = versionPhrase(deck.since, manifest.about.knowledge.version);
+  const document = `${deck.slug}${handout ? "#handout" : ""}`;
+  const trailer = trailerId(manifest, document, deck.since);
+  return [
+    `% The deck's ${handout ? "handout: each slide followed by its notes" : "slides"}. Compile with \`latexmk${handout ? " handout.tex" : ""}\` (LuaLaTeX, see latexmkrc).`,
+    "% A fixed seed for TeX's random numbers: the same source gives the same PDF.",
+    "\\ExplSyntaxOn \\sys_gset_rand_seed:n { 1 } \\ExplSyntaxOff",
+    // usepdftitle=false: the title below is the PDF's, not beamer's "title - subtitle".
+    `\\documentclass[aspectratio=${ratio},11pt,usepdftitle=false${handout ? ",handout" : ""}]{beamer}`,
+    `\\usetheme${scripts ? "[scripts]" : ""}{explico}`,
+    ...handout ? ["\\setbeameroption{show notes}"] : [],
+    `\\ifdefined\\directlua\\pdfvariable trailerid {[<${trailer}><${trailer}>]}\\else\\pdftrailerid{${trailer}}\\fi`,
+    `\\title{${escapeText(deck.title)}}`,
+    `\\subtitle{${escapeText(course)}}`,
+    `\\author{${escapeText(authors || course)}}`,
+    `\\date{Content ${escapeText(version)}}`,
+    `\\hypersetup{pdftitle={${escapeText(deck.title)}},pdfauthor={${escapeText(authors || course)}},pdfsubject={${escapeText(course)}}}`,
+    "\\begin{document}",
+    "\\input{deck}",
+    "\\end{document}",
+    ""
+  ].join("\n");
+}
+function deckReadme(manifest, deck, url) {
+  const course = manifest.about.material.name;
+  return [
+    `# ${deck.title} \u2014 slides`,
+    "",
+    `The LaTeX source of a deck of *${course}*, ${versionPhrase(deck.since, manifest.about.knowledge.version)}.` + (url ? ` Its interactive version: ${url}` : ""),
+    "",
+    "- `main.tex` \u2014 the slides: `latexmk` builds `main.pdf`.",
+    "- `handout.tex` \u2014 each slide followed by its speaker notes: `latexmk handout.tex`.",
+    "- `deck.tex` \u2014 the frames, which both read.",
+    "- `beamerthemeexplico.sty` \u2014 explico's beamer theme: the legend line, the frame number, the progress bar.",
+    "- `explico-common.sty` \u2014 what the theme shares with explico's book class: fonts, colours, figures,",
+    "  diagrams and the notation markers.",
+    "- `figures/` \u2014 the deck's figures, as vector PDF where the website draws them.",
+    "- `latexmkrc` \u2014 LuaLaTeX by default; `latexmk -pdf` uses pdfLaTeX.",
+    "",
+    "Beamer cannot write a tagged PDF: these PDFs are not accessible to a screen reader. The deck's",
+    "web page and its chapter's PDF are.",
+    ""
+  ].join("\n");
+}
+function deckSource(input) {
+  const { manifest, deck, page } = input;
+  const base = manifest.lessonExports.canonicalBaseUrl;
+  const url = base ? `${base}${deck.slug}/` : void 0;
+  const context = {
+    deck: page,
+    documentRoutes: /* @__PURE__ */ new Set([page.route]),
+    ...base ? { canonicalBaseUrl: base } : {},
+    pictures: new Map([...input.pictures].map(([anchor, picture]) => [anchor, picture.path])),
+    checkItems: input.checkItems
+  };
+  const appendix = deckSymbols(context);
+  const serialized = serializeDeck({
+    ...context,
+    appendix,
+    notationTargets: new Set(appendix.map((entry) => entry.key))
+  });
+  const scripts = input.scripts ?? needsScripts(serialized.tex);
+  const files = [
+    { path: "main.tex", content: deckMain(manifest, deck, false, scripts) },
+    { path: "handout.tex", content: deckMain(manifest, deck, true, scripts) },
+    { path: "deck.tex", content: serialized.tex },
+    { path: "beamerthemeexplico.sty", content: deckTheme() },
+    { path: "explico-common.sty", content: explicoCommon() },
+    { path: "latexmkrc", content: LATEXMKRC },
+    { path: "README.md", content: deckReadme(manifest, deck, url) },
+    ...[...input.pictures.values()].map((picture) => ({ path: picture.path, content: picture.content }))
+  ];
+  return { files, frameEnds: serialized.frameEnds };
+}
+function deckNumberingProblems(aux, frames) {
+  const numbers = /* @__PURE__ */ new Map();
+  for (const match of aux.matchAll(/\\newlabel\{frame:(\d+)\}\{\{(\d+)\}/gu)) {
+    numbers.set(Number(match[1]), Number(match[2]));
+  }
+  const problems = [];
+  for (let frame = 1; frame <= frames; frame += 1) {
+    const printed = numbers.get(frame);
+    if (printed === void 0) problems.push(`slide ${frame} has no frame in the PDF`);
+    else if (printed !== frame) problems.push(`slide ${frame} is frame ${printed} in the PDF`);
+  }
+  return problems;
+}
+function deckOverflows(log, frameEnds) {
+  const ends = [...frameEnds].sort((a, b) => a[1] - b[1]);
+  const found = /* @__PURE__ */ new Map();
+  for (const match of log.matchAll(/Overfull \\vbox \(([\d.]+)pt too high\) detected at line (\d+)/gu)) {
+    const line = Number(match[2]);
+    const frame = ends.find(([, end]) => line <= end + 1)?.[0];
+    if (frame !== void 0) found.set(frame, Math.max(found.get(frame) ?? 0, Number(match[1])));
+  }
+  return [...found].map(([frame, points]) => ({ frame, points: Math.round(points) })).sort((a, b) => a.frame - b.frame);
+}
+export {
+  deckNotationKeys,
+  deckNumberingProblems,
+  deckOverflows,
+  deckSource,
+  deckSymbols,
+  deckTheme,
+  serializeDeck
+};

package/dist/compiler/exports/latex/document.d.ts

@@ -1,9 +1,9 @@
-import { ManifestLesson, ManifestPart, Manifest } from '../../manifest.js';
+import { ManifestLesson, ManifestPart, Manifest, ManifestDeck } from '../../manifest.js';
 import { StaticPage } from '../static-tree.js';
 import { CheckItem } from './serialize.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,6 +25,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';
 import '../html-tree.js';
 import 'parse5';
@@ -41,18 +45,33 @@ interface SourceFile {
 }
 /** explico's class, shipped next to this module (copied into `dist/` by `copy-assets`). */
 declare function explicoClass(): string;
+/** `explico-common.sty`: what the book class and the deck theme share. */
+declare function explicoCommon(): string;
 /** `parts/02-projectiles/02-optimal-launch-angle.tex` for chapter 2.2. */
 declare function chapterPath(manifest: Pick<Manifest, 'parts'>, lesson: ManifestLesson): string;
 /** The folder name a chapter's download unzips to. */
 declare function chapterFolderName(lesson: ManifestLesson): string;
 /** A chapter's check answers, by assessment id, in authored order. */
 declare function checkItems(manifest: Pick<Manifest, 'assessmentContent'>, lesson: Pick<ManifestLesson, 'id'>): Map<string, CheckItem[]>;
+/**
+ * The items a deck's question frames ask: its lesson's checks, or on a
+ * part's deck those of each chapter it covers, as its frames show them
+ * (an assessment two chapters share, as the first one does).
+ */
+declare function deckCheckItems(manifest: Pick<Manifest, 'assessmentContent'>, deck: Pick<ManifestDeck, 'lessonId' | 'covers'>): Map<string, CheckItem[]>;
 /**
  * The PDF's file identifier (its trailer `/ID`), which the engines derive
- * from the output file's path unless told: fixed from the course, its
- * content version and the document, so every compile of a source agrees.
+ * from the output file's path unless told: fixed from the course, the
+ * version the document's content is at (rule C5) and the document, so every
+ * compile of a source agrees, and a release that left the document alone
+ * leaves its identifier.
+ */
+declare function trailerId(manifest: Pick<Manifest, 'about'>, document: string, since: string | null): string;
+/**
+ * The version a book's content is at: the newest among its chapters and
+ * part pages, `null` when any has a change not yet released.
  */
-declare function trailerId(manifest: Pick<Manifest, 'about'>, document: string): string;
+declare function bookSince(parts: readonly BookPart[]): string | null;
 interface ChapterSourceInput {
     readonly manifest: Manifest;
     readonly lesson: ManifestLesson;
@@ -67,6 +86,19 @@ interface ChapterSourceInput {
 }
 /** Every file of one chapter's LaTeX folder. */
 declare function chapterSource(input: ChapterSourceInput): SourceFile[];
+/**
+ * The document's files, with the class option `scripts` on `main.tex` when a
+ * `.tex` file holds a character of another script: the class then loads its
+ * fallback fonts under LuaLaTeX, which costs every compile that does not
+ * need them about two seconds.
+ */
+/**
+ * Whether a document's LaTeX holds a character of another script, so its
+ * class (or a deck's theme) should load the fallback fonts. A Greek letter on
+ * its own is a symbol set as math; a Greek word (`\ExplicoGreekWord`), an
+ * accented letter or another script needs a text font.
+ */
+declare function needsScripts(tex: string): boolean;
 /** A chapter of a book, with its figure files. */
 interface BookChapter {
     readonly lesson: ManifestLesson;
@@ -76,11 +108,24 @@ interface BookChapter {
         readonly content: Uint8Array;
     }>;
 }
+/**
+ * A lesson of a book's part that has no chapter, only slides (a slides-first
+ * lesson, docs/authoring/deck.md): the book keeps its place and its number
+ * with a short chapter that points at the slides.
+ */
+interface BookSlidesLesson {
+    readonly lesson: ManifestLesson;
+    /** The deck's PDF and interactive version, when the course publishes them. */
+    readonly slidesUrl?: string;
+    readonly outcomes: readonly string[];
+}
 /** A part of a book: its own page, when it has one, and its chapters in order. */
 interface BookPart {
     readonly part: ManifestPart;
     readonly overview?: StaticPage;
     readonly chapters: readonly BookChapter[];
+    /** Its slides-first lessons, placed among the chapters by their chapter number. */
+    readonly slides?: readonly BookSlidesLesson[];
 }
 interface BookSourceInput {
     readonly manifest: Manifest;
@@ -99,4 +144,4 @@ interface BookSourceInput {
  */
 declare function bookSource(input: BookSourceInput): SourceFile[];
 
-export { type BookChapter, type BookPart, type BookSourceInput, type ChapterSourceInput, type SourceFile, bookSource, chapterFolderName, chapterPath, chapterSource, checkItems, explicoClass, trailerId };
+export { type BookChapter, type BookPart, type BookSlidesLesson, type BookSourceInput, type ChapterSourceInput, type SourceFile, bookSince, bookSource, chapterFolderName, chapterPath, chapterSource, checkItems, deckCheckItems, explicoClass, explicoCommon, needsScripts, trailerId };