explico 0.13.1 → 0.15.0

package/dist/compiler/collections.d.ts

@@ -20,6 +20,73 @@ import { ContentRecord } from '../reference/gate-retired-keys.js';
  * ignoring code fences and inline code, sorted by position.
  */
 declare function extractNotationReferences(text: string, file: string, kind: NotationReferenceInput['kind'] | undefined): NotationReferenceInput[];
+/** What every deck file is, whichever it belongs to ({@link DeckFile}). */
+interface DeckFileBase {
+    /** Absolute path of the deck file. */
+    readonly path: string;
+    /** Repository-relative path, the `file` of its diagnostics. */
+    readonly file: string;
+    /** Docs slug of the deck file, extension included: `motion/range.deck.mdx`. */
+    readonly slug: string;
+    /** Where the deck is served: `motion/range/slides`, `motion/range` alone, or a part's `motion/slides`. */
+    readonly route: string;
+    /** The id of the deck's page: `motion.range.slides`, the lesson's id alone, or a part's `motion.slides`. */
+    readonly pageId: string;
+    /** The part directory the deck sits in: `motion`; empty for a deck outside one. */
+    readonly partDir: string;
+    /** True when the deck sits in a part's directory, as a lesson does. */
+    readonly inPart: boolean;
+    /** The deck file's frontmatter. */
+    readonly data: Record<string, unknown>;
+    readonly body: string;
+    /** 1-based file line {@link body} starts on. */
+    readonly bodyLine: number;
+}
+/**
+ * A lesson's deck (`<lesson>.deck.mdx`): its slide edition, beside the
+ * lesson's chapter or, for a lesson that is only slides, alone. See
+ * `docs/authoring/deck.md`.
+ */
+interface LessonDeckFile extends DeckFileBase {
+    readonly scope: 'lesson';
+    /** The lesson's slug: `motion/range`. */
+    readonly lessonSlug: string;
+    readonly lessonId: string;
+    /** The lesson's chapter file, when it has one. */
+    readonly chapterPath?: string;
+}
+/**
+ * A part's deck (`<part>/index.deck.mdx`, beside the part's page): the
+ * slides of the part, whose sections may name the chapters they cover. It
+ * belongs to no lesson.
+ */
+interface PartDeckFile extends DeckFileBase {
+    readonly scope: 'part';
+}
+/** A deck file: a lesson's slide edition, or a part's deck. */
+type DeckFile = LessonDeckFile | PartDeckFile;
+/**
+ * Every deck file, by slug: each lesson's, and each part's. A part's deck
+ * (`<part>/index.deck.mdx`) is never read as the deck of a lesson
+ * `<part>/index` whose chapter is the part's page.
+ */
+declare function loadDeckFiles(): DeckFile[];
+/**
+ * A file that defines a lesson: every chapter, and every deck whose lesson has
+ * no chapter (a slides-first lesson). Its frontmatter is the lesson's —
+ * `teaches`, `assumptions`, `studyMinutes`, `notation` — and its body is what
+ * the lesson's numbering and curriculum passes read.
+ */
+interface LessonFile {
+    readonly path: string;
+    /** Docs slug of the file, extension included. */
+    readonly slug: string;
+    readonly lessonSlug: string;
+    readonly lessonId: string;
+    readonly edition: 'chapter' | 'deck';
+}
+/** Every lesson's defining file, sorted by lesson slug. */
+declare function loadLessonFiles(): LessonFile[];
 /**
  * One part's **overview page** — `content/docs/<dir>/index.mdx`, the page the
  * part's own directory URL resolves to. `isLessonSlug` already excludes any
@@ -55,6 +122,26 @@ declare function loadAbbreviationRegistryInput(): Promise<readonly AbbreviationD
  * decoration (the page would contradict itself) each fail the load.
  */
 declare function notationSuspensions(raw: unknown, localDefinitions: readonly LocalNotationDefinitionInput[], file: string): NotationSuspension[];
+/**
+ * A deck beside its chapter, as a page of the notation registry: its own id
+ * (`<lessonId>.slides`), no entries of its own, and its chapter's scope — the
+ * chapter's `notation.local` entries are the lesson's, so a deck names them
+ * as the chapter does, and it suspends what the chapter suspends. A part's
+ * deck (`<part>.slides`) has its part's scope: every chapter of the part, in
+ * the order the tracks read them, a key one chapter defines locally binding
+ * to the first that does; it suspends what any of them suspends. A deck that
+ * is a lesson's only edition is not here: it is that lesson's page
+ * (`loadNotationRegistryInput`).
+ */
+interface DeckNotationPage {
+    readonly deck: DeckFile;
+    readonly data: Record<string, unknown>;
+    readonly notation: NotationLessonInput;
+}
+declare function loadDeckNotationPages(decks?: readonly DeckFile[], { order, }?: {
+    /** The lessons of a part in reading order (the tracks'); by slug without it. */
+    readonly order?: (lessonIds: readonly string[]) => readonly string[];
+}): DeckNotationPage[];
 /**
  * A docs page that is **not a chapter** (rule S10): the landing page, a part's
  * overview page, and any other page outside a part directory — every slug
@@ -132,4 +219,4 @@ declare function notationSourceLocatorGaps(): {
     total: number;
 };
 
-export { type NonChapterPage, type NotationSpec, type PartOverviewPage, extractNotationReferences, loadAbbreviationRegistryInput, loadContentRecords, loadCurriculumCatalog, loadLessonChecks, loadNonChapterPages, loadNotationDefinitions, loadNotationRegistryInput, loadNotationSpecs, loadPartOverviews, loadSourceRecords, notationSourceLocatorGaps, notationSuspensions };
+export { type DeckFile, type DeckNotationPage, type LessonDeckFile, type LessonFile, type NonChapterPage, type NotationSpec, type PartDeckFile, type PartOverviewPage, extractNotationReferences, loadAbbreviationRegistryInput, loadContentRecords, loadCurriculumCatalog, loadDeckFiles, loadDeckNotationPages, loadLessonChecks, loadLessonFiles, loadNonChapterPages, loadNotationDefinitions, loadNotationRegistryInput, loadNotationSpecs, loadPartOverviews, loadSourceRecords, notationSourceLocatorGaps, notationSuspensions };

package/dist/compiler/collections.js

@@ -16,11 +16,19 @@ import { resolveGlosses } from "../reference/gloss.js";
 import { indexEntryFormula } from "../reference/derived-notation.mjs";
 import { isIndexEntryLatex } from "./content-schemas.js";
 import {
+  deckLessonSlug,
+  deckPageId,
+  deckRouteSlug,
   deriveRequires,
   deriveSources,
+  isDeckSlug,
   isLessonSlug,
+  isPartDeckSlug,
   lessonIdFromSlug,
-  parseCheckList
+  parseCheckList,
+  partDeckDir,
+  partDeckPageId,
+  partDeckRouteSlug
 } from "./lesson-derivation.js";
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
@@ -186,9 +194,81 @@ function docSlug(path) {
   return relative(join(CONTENT_ROOT, "docs"), path).replace(/\\/g, "/");
 }
 function lessonCheckIds(lessonPath) {
-  const checksPath = lessonPath.replace(/\.mdx?$/, ".checks.yml");
+  const checksPath = lessonPath.replace(/(?:\.deck)?\.mdx?$/, ".checks.yml");
   return existsSync(checksPath) ? parseCheckList(readFileSync(checksPath, "utf8")) : [];
 }
+function docsFiles() {
+  const root = join(CONTENT_ROOT, "docs");
+  return existsSync(root) ? filesBelow(root, [".md", ".mdx"]) : [];
+}
+function chapterPathOf(lessonSlug) {
+  for (const extension of [".mdx", ".md"]) {
+    const path = join(CONTENT_ROOT, "docs", `${lessonSlug}${extension}`);
+    if (existsSync(path)) return path;
+  }
+  return void 0;
+}
+function loadDeckFiles() {
+  const decks = [];
+  for (const path of docsFiles()) {
+    const slug = docSlug(path);
+    if (!isDeckSlug(slug)) continue;
+    const { file, data, body, bodyLine } = parseDocument(path);
+    if (isPartDeckSlug(slug)) {
+      const partDir = partDeckDir(slug);
+      decks.push({
+        scope: "part",
+        path,
+        file,
+        slug,
+        route: partDeckRouteSlug(partDir),
+        pageId: partDeckPageId(partDir),
+        partDir,
+        inPart: true,
+        data,
+        body,
+        bodyLine
+      });
+      continue;
+    }
+    const lessonSlug = deckLessonSlug(slug);
+    const lessonId = lessonIdFromSlug(lessonSlug);
+    const chapterPath = chapterPathOf(lessonSlug);
+    const hasChapter = chapterPath !== void 0;
+    decks.push({
+      scope: "lesson",
+      path,
+      file,
+      slug,
+      lessonSlug,
+      lessonId,
+      ...chapterPath === void 0 ? {} : { chapterPath },
+      route: deckRouteSlug(lessonSlug, hasChapter),
+      pageId: deckPageId(lessonId, hasChapter),
+      partDir: lessonSlug.includes("/") ? lessonSlug.slice(0, lessonSlug.indexOf("/")) : "",
+      inPart: lessonSlug.includes("/") && !lessonSlug.endsWith("/index"),
+      data,
+      body,
+      bodyLine
+    });
+  }
+  return decks;
+}
+function loadLessonFiles() {
+  const lessons = [];
+  for (const path of docsFiles()) {
+    const slug = docSlug(path);
+    if (isLessonSlug(slug)) {
+      const lessonSlug = slug.replace(/\.(md|mdx)$/, "");
+      lessons.push({ path, slug, lessonSlug, lessonId: lessonIdFromSlug(slug), edition: "chapter" });
+    } else if (isDeckSlug(slug) && slug.includes("/") && !isPartDeckSlug(slug)) {
+      const lessonSlug = deckLessonSlug(slug);
+      if (chapterPathOf(lessonSlug) !== void 0) continue;
+      lessons.push({ path, slug, lessonSlug, lessonId: lessonIdFromSlug(lessonSlug), edition: "deck" });
+    }
+  }
+  return lessons.sort((left, right) => left.lessonSlug.localeCompare(right.lessonSlug));
+}
 function loadPartOverviews(parts) {
   const pages = [];
   for (const { dir } of parts) {
@@ -214,17 +294,19 @@ function loadPartOverviews(parts) {
 }
 function lessonEntries(prerequisitesById) {
   const lessons = [];
-  for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
-    const slug = docSlug(path);
-    if (!isLessonSlug(slug)) continue;
+  const deckBodies = new Map(
+    loadDeckFiles().filter((deck) => deck.scope === "lesson" && deck.chapterPath !== void 0).map((deck) => [deck.lessonId, parseDocument(deck.path).body])
+  );
+  for (const { path, lessonId } of loadLessonFiles()) {
     const { data, body } = parseDocument(path);
     const teaches = data.teaches ?? [];
+    const deckBody = deckBodies.get(lessonId);
     lessons.push({
-      id: lessonIdFromSlug(slug),
+      id: lessonId,
       requires: deriveRequires(teaches, prerequisitesById),
       teaches,
       assessments: lessonCheckIds(path),
-      sources: deriveSources(body),
+      sources: deckBody === void 0 ? deriveSources(body) : [.../* @__PURE__ */ new Set([...deriveSources(body), ...deriveSources(deckBody)])].sort(),
       assumptions: data.assumptions ?? [],
       body
     });
@@ -317,7 +399,7 @@ function localDefinition(raw, file, index) {
 function sharedNotationEntries() {
   const directory = join(CONTENT_ROOT, "notation");
   return filesBelow(directory, [".md"]).map((path) => {
-    const { file, data, body } = parseDocument(path);
+    const { file, data, body, bodyLine } = parseDocument(path);
     const key = string(data.key, `${file} key`);
     const filenameKey = basename(path, ".md");
     if (key !== filenameKey) {
@@ -339,6 +421,7 @@ function sharedNotationEntries() {
       alignment: data.alignment === void 0 ? { kind: "general", rationale: "General notation." } : alignment(data.alignment, `${file} alignment`),
       aiAssisted: data.aiAssisted === void 0 ? false : boolean(data.aiAssisted, `${file} aiAssisted`),
       body,
+      bodyLine,
       references: extractNotationReferences(body, file, void 0),
       glosses: glossEntries(data.glosses, key, `${file} glosses`),
       source: { file },
@@ -403,21 +486,26 @@ function notationSuspensions(raw, localDefinitions, file) {
     return reason === void 0 ? { operator } : { operator, reason: reason.trim() };
   });
 }
+function lessonNotationOf(file, data) {
+  const notation = record(data.notation ?? {}, `${file} notation`);
+  const local = Array.isArray(notation.local) ? notation.local : [];
+  const localDefinitions = local.map(
+    (entry, index) => localDefinition(entry, file, index)
+  );
+  return {
+    localDefinitions,
+    suspended: notationSuspensions(notation.suspend, localDefinitions, file)
+  };
+}
 function notationLessonEntries() {
   const lessons = [];
-  for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
-    const slug = docSlug(path);
-    if (!isLessonSlug(slug)) continue;
+  for (const { path, lessonId } of loadLessonFiles()) {
     const { file, data, body, bodyLine } = parseDocument(path);
-    const notation = record(data.notation ?? {}, `${file} notation`);
-    const local = Array.isArray(notation.local) ? notation.local : [];
-    const localDefinitions = local.map(
-      (entry, index) => localDefinition(entry, file, index)
-    );
+    const { localDefinitions, suspended } = lessonNotationOf(file, data);
     lessons.push({
-      lessonId: lessonIdFromSlug(slug),
+      lessonId,
       localDefinitions,
-      suspended: notationSuspensions(notation.suspend, localDefinitions, file),
+      suspended,
       references: extractNotationReferences(body, file, void 0),
       body,
       bodyLine,
@@ -426,11 +514,68 @@ function notationLessonEntries() {
   }
   return lessons;
 }
+function loadDeckNotationPages(decks = loadDeckFiles(), {
+  order = (lessonIds) => lessonIds
+} = {}) {
+  const pages = [];
+  const chapterFiles = loadLessonFiles().filter((lesson) => lesson.edition === "chapter");
+  for (const deck of decks) {
+    let chapters;
+    if (deck.scope === "part") {
+      const inPart = chapterFiles.filter((lesson) => lesson.lessonSlug.startsWith(`${deck.partDir}/`));
+      const pathById = new Map(inPart.map((lesson) => [lesson.lessonId, lesson.path]));
+      chapters = order(inPart.map((lesson) => lesson.lessonId)).flatMap((lessonId) => {
+        const path = pathById.get(lessonId);
+        return path === void 0 ? [] : [{ lessonId, path }];
+      });
+    } else if (deck.chapterPath !== void 0) {
+      chapters = [{ lessonId: deck.lessonId, path: deck.chapterPath }];
+    } else {
+      continue;
+    }
+    const inheritedLocalDefinitions = [];
+    const suspended = [];
+    const inheritedKeys = /* @__PURE__ */ new Set();
+    for (const { path } of chapters) {
+      const chapter = parseDocument(path);
+      const notation = lessonNotationOf(chapter.file, chapter.data);
+      for (const definition of notation.localDefinitions) {
+        if (!inheritedLocalDefinitions.some((known) => known.key === definition.key)) {
+          inheritedLocalDefinitions.push(definition);
+        }
+      }
+      for (const suspension of notation.suspended) {
+        if (!suspended.some((known) => known.operator === suspension.operator)) suspended.push(suspension);
+      }
+      for (const reference of extractNotationReferences(chapter.body, chapter.file, void 0)) {
+        inheritedKeys.add(reference.key);
+      }
+    }
+    const { file, data, body, bodyLine } = deck;
+    pages.push({
+      deck,
+      data,
+      notation: {
+        lessonId: deck.pageId,
+        localDefinitions: [],
+        suspended,
+        scopeLessonIds: chapters.map((chapter) => chapter.lessonId),
+        inheritedLocalDefinitions,
+        inheritedKeys: [...inheritedKeys].sort(),
+        references: extractNotationReferences(body, file, void 0),
+        body,
+        bodyLine,
+        source: { file }
+      }
+    });
+  }
+  return pages;
+}
 function loadNonChapterPages() {
   const pages = [];
-  for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
+  for (const path of docsFiles()) {
     const slug = docSlug(path);
-    if (isLessonSlug(slug)) continue;
+    if (isLessonSlug(slug) || isDeckSlug(slug)) continue;
     const { file, data, body, bodyLine } = parseDocument(path);
     const id = lessonIdFromSlug(slug);
     pages.push({
@@ -500,7 +645,7 @@ function loadSourceRecords() {
 }
 function loadLessonChecks(lessonId) {
   const slug = lessonId.replace(/\./g, "/");
-  for (const extension of [".mdx", ".md"]) {
+  for (const extension of [".mdx", ".md", ".deck.mdx", ".deck.md"]) {
     const lessonPath = join(CONTENT_ROOT, "docs", `${slug}${extension}`);
     if (existsSync(lessonPath)) return lessonCheckIds(lessonPath);
   }
@@ -534,11 +679,8 @@ function loadNotationSpecs() {
       sources: specSources(data.sources)
     });
   }
-  for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
-    const slug = docSlug(path);
-    if (!isLessonSlug(slug)) continue;
+  for (const { path, lessonId } of loadLessonFiles()) {
     const { file, data } = parseDocument(path);
-    const lessonId = lessonIdFromSlug(slug);
     const local = data.notation?.local;
     if (!Array.isArray(local)) continue;
     for (const raw of local) {
@@ -576,7 +718,10 @@ export {
   loadAbbreviationRegistryInput,
   loadContentRecords,
   loadCurriculumCatalog,
+  loadDeckFiles,
+  loadDeckNotationPages,
   loadLessonChecks,
+  loadLessonFiles,
   loadNonChapterPages,
   loadNotationDefinitions,
   loadNotationRegistryInput,

package/dist/compiler/content-release.d.ts

@@ -0,0 +1,49 @@
+import { EditPlan } from './cli.js';
+import '../reference/types.js';
+import '../reference/gate-math.js';
+import './manifest.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/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/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 './render-diagnostics.js';
+import '../rules/in-effect.js';
+
+type ReleaseBump = 'major' | 'minor' | 'patch';
+interface ReleaseEdit {
+    readonly from: string;
+    readonly to: string;
+    readonly bump: ReleaseBump;
+    /** True when the bump was read from the section's headings, not asked for. */
+    readonly inferred: boolean;
+    readonly changelog: string;
+    readonly config: string;
+}
+/** The release of these two files' text on `date` (`YYYY-MM-DD`); `null` when `[Unreleased]` has no entry. */
+declare function releaseEdit(changelog: string, config: string, date: string, requested?: ReleaseBump): ReleaseEdit | null;
+declare function planContentRelease(requested?: string, date?: string): EditPlan;
+
+export { type ReleaseBump, type ReleaseEdit, planContentRelease, releaseEdit };

package/dist/compiler/content-release.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ContentCliError } from "./cli.js";
+const CHANGELOG = "content/CHANGELOG.md";
+const CONFIG = "content/course.config.ts";
+function releaseEdit(changelog, config, date, requested) {
+  const unreleased = /^## \[Unreleased\]\r?$/m.exec(changelog);
+  if (!unreleased) throw new ContentCliError("no-changelog", `${CHANGELOG} has no "## [Unreleased]" heading.`);
+  const bodyStart = unreleased.index + unreleased[0].length;
+  const released = /^## \[\d+\.\d+\.\d+\](?: - .*?)?\r?$/m.exec(changelog.slice(bodyStart));
+  if (!released) throw new ContentCliError("no-changelog", `${CHANGELOG} has no released "## [x.y.z]" heading below "## [Unreleased]".`);
+  const bodyEnd = bodyStart + released.index;
+  const body = changelog.slice(bodyStart, bodyEnd);
+  if (!/^-\s+/m.test(body)) return null;
+  const version = /(about:\s*\{[\s\S]*?\bversion:\s*['"])(\d+)\.(\d+)\.(\d+)(['"])/.exec(config);
+  if (!version) throw new ContentCliError("unknown-version", `No about.version "x.y.z" in ${CONFIG}.`);
+  const [major, minor, patch] = version.slice(2, 5).map(Number);
+  const implied = /^### (Breaking|Removed)\s*$/m.test(body) ? "major" : /^### Added\s*$/m.test(body) ? "minor" : "patch";
+  const bump = requested ?? implied;
+  const to = bump === "major" ? `${major + 1}.0.0` : bump === "minor" ? `${major}.${minor + 1}.0` : `${major}.${minor}.${patch + 1}`;
+  return {
+    from: `${major}.${minor}.${patch}`,
+    to,
+    bump,
+    inferred: requested === void 0,
+    changelog: `${changelog.slice(0, bodyStart)}
+
+## [${to}] - ${date}${body}${changelog.slice(bodyEnd)}`,
+    config: config.replace(version[0], `${version[1]}${to}${version[5]}`)
+  };
+}
+function localDate(now = /* @__PURE__ */ new Date()) {
+  return [now.getFullYear(), now.getMonth() + 1, now.getDate()].map((n, i) => String(n).padStart(i === 0 ? 4 : 2, "0")).join("-");
+}
+function planContentRelease(requested, date = localDate()) {
+  if (requested !== void 0 && requested !== "major" && requested !== "minor" && requested !== "patch") {
+    throw new ContentCliError("usage", `content release takes major, minor or patch; got ${requested}.`);
+  }
+  for (const file of [CHANGELOG, CONFIG]) {
+    if (!existsSync(join(process.cwd(), file))) throw new ContentCliError("no-changelog", `No ${file} in this course.`);
+  }
+  const changelog = readFileSync(join(process.cwd(), CHANGELOG), "utf8");
+  const config = readFileSync(join(process.cwd(), CONFIG), "utf8");
+  const edit = releaseEdit(changelog, config, date, requested);
+  if (edit === null) {
+    return { summary: ["## [Unreleased] has no entries: nothing to release"], edits: [], next: [] };
+  }
+  return {
+    summary: [
+      `about.version ${edit.from} \u2192 ${edit.to} (${edit.bump}${edit.inferred ? ", from the section's headings" : ""})`,
+      `${CHANGELOG}: ## [Unreleased] \u2192 ## [${edit.to}] - ${date}, a fresh ## [Unreleased] above it`
+    ],
+    edits: [
+      { file: CHANGELOG, before: changelog, after: edit.changelog },
+      { file: CONFIG, before: config, after: edit.config }
+    ],
+    next: ["pnpm validate:content (records the release in content/versions.json)", "commit the changelog, the config and content/versions.json together"]
+  };
+}
+export {
+  planContentRelease,
+  releaseEdit
+};

package/dist/compiler/content-schemas.d.ts

@@ -178,9 +178,9 @@ declare const trackSchema: z.ZodObject<{
 declare const sourceSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<{
+        paper: "paper";
         primary: "primary";
         "official-guidance": "official-guidance";
-        paper: "paper";
         book: "book";
         secondary: "secondary";
     }>;
@@ -359,9 +359,9 @@ declare const CONTENT_SCHEMAS: {
     readonly sources: z.ZodObject<{
         id: z.ZodString;
         type: z.ZodEnum<{
+            paper: "paper";
             primary: "primary";
             "official-guidance": "official-guidance";
-            paper: "paper";
             book: "book";
             secondary: "secondary";
         }>;

package/dist/compiler/course-config.d.ts

@@ -1,3 +1,3 @@
-export { s as BLOCK_LABELS_DEFAULT, B as BlockLabels, t as CARDS_DEFAULTS, h as CourseAbbreviations, u as CourseAbout, g as CourseAccents, v as CourseAuthor, w as CourseCards, C as CourseConfig, x as CourseDisclosure, y as CourseHeadingDisclosure, z as CourseNumbering, A as CourseOpenDefault, e as CourseOperators, D as CoursePart, f as CourseRomanLabels, E as CourseSection, F as DISCLOSURE_DEFAULTS, L as LessonExportsConfig, c as NormalizedCards, a as NormalizedDisclosure, N as NormalizedLessonExports, b as NormalizedNumbering, i as NormalizedPartPages, G as coursePartsOf, H as normalizeBlockLabels, I as normalizeCards, J as normalizeDisclosure, K as normalizeLessonExports, O as normalizeNumbering } from '../course-config-rRtME5UV.js';
+export { A as APPEARANCE_DEFAULTS, x as AppearanceSlides, y as AppearanceZones, z as BLOCK_LABELS_DEFAULT, B as BlockLabels, D as CARDS_DEFAULTS, l as CourseAbbreviations, E as CourseAbout, k as CourseAccents, F as CourseAppearance, G as CourseAuthor, H as CourseCards, C as CourseConfig, I as CourseDeck, J as CourseDisclosure, K as CourseHeadingDisclosure, L as CourseNumbering, O as CourseOpenDefault, i as CourseOperators, P as CoursePart, j as CourseRomanLabels, Q as CourseSection, S as CourseSidebarEditions, T as CourseSidebarMarks, U as DECK_CANVAS, V as DECK_DEFAULTS, W as DISCLOSURE_DEFAULTS, X as DeckAspectRatio, Y as DeckLegend, Z as DeckNotes, _ as LessonExportsConfig, f as NormalizedAppearance, c as NormalizedCards, g as NormalizedDeck, a as NormalizedDisclosure, N as NormalizedLessonExports, b as NormalizedNumbering, m as NormalizedPartPages, e as NormalizedSidebarEditions, d as NormalizedSidebarMarks, R as ReadingMemorySetting, $ as SIDEBAR_EDITIONS_DEFAULTS, a0 as SIDEBAR_MARKS_DEFAULTS, a1 as SidebarEditionLead, a2 as SidebarEditionOther, a3 as coursePartsOf, a4 as normalizeAppearance, a5 as normalizeBlockLabels, a6 as normalizeCards, a7 as normalizeDeck, a8 as normalizeDisclosure, a9 as normalizeLessonExports, aa as normalizeNumbering, ab as normalizeReadingMemory, ac as normalizeSidebarEditions, ad as normalizeSidebarMarks } from '../course-config-BLtIdkei.js';
 import '../rules/course-rules.js';
 import '../rules/catalog.js';

package/dist/compiler/course-config.js

@@ -83,6 +83,100 @@ function normalizeCards(config) {
   }
   return { carry };
 }
+const SIDEBAR_MARKS_DEFAULTS = { unopened: true, changed: true };
+function normalizeSidebarMarks(config) {
+  const marks = config.sidebarMarks ?? {};
+  const read = (field) => {
+    const value = marks[field] ?? SIDEBAR_MARKS_DEFAULTS[field];
+    if (typeof value !== "boolean") {
+      throw new Error(
+        `CourseConfig sidebarMarks.${field} must be true or false; received ${JSON.stringify(value)}.`
+      );
+    }
+    return value;
+  };
+  return { unopened: read("unopened"), changed: read("changed") };
+}
+const SIDEBAR_EDITIONS_DEFAULTS = { lead: "chapter", other: "listed" };
+function normalizeSidebarEditions(config) {
+  const editions = config.sidebarEditions ?? {};
+  const choice = (field, allowed) => {
+    const value = editions[field] ?? SIDEBAR_EDITIONS_DEFAULTS[field];
+    if (typeof value !== "string" || !allowed.includes(value)) {
+      throw new Error(
+        `CourseConfig sidebarEditions.${field} must be one of ${allowed.map((item) => JSON.stringify(item)).join(", ")}; received ${JSON.stringify(value)}.`
+      );
+    }
+    return value;
+  };
+  return {
+    lead: choice("lead", ["chapter", "slides"]),
+    other: choice("other", ["listed", "hidden"])
+  };
+}
+const DECK_CANVAS = {
+  "16:9": { width: 800, height: 450 },
+  "16:10": { width: 720, height: 450 },
+  "4:3": { width: 600, height: 450 }
+};
+const DECK_DEFAULTS = {
+  aspectRatio: "16:9",
+  legend: "first-use",
+  notes: "reader",
+  outcomesFrame: true,
+  handoutPdf: true
+};
+function normalizeDeck(config) {
+  const deck = config.deck ?? {};
+  const choice = (field, allowed) => {
+    const value = deck[field] ?? DECK_DEFAULTS[field];
+    if (typeof value !== "string" || !allowed.includes(value)) {
+      throw new Error(
+        `CourseConfig deck.${field} must be one of ${allowed.map((item) => JSON.stringify(item)).join(", ")}; received ${JSON.stringify(value)}.`
+      );
+    }
+    return value;
+  };
+  const flag = (field) => {
+    const value = deck[field] ?? DECK_DEFAULTS[field];
+    if (typeof value !== "boolean") {
+      throw new Error(`CourseConfig deck.${field} must be true or false; received ${JSON.stringify(value)}.`);
+    }
+    return value;
+  };
+  const aspectRatio = choice("aspectRatio", ["16:9", "16:10", "4:3"]);
+  return {
+    aspectRatio,
+    legend: choice("legend", ["first-use", "every-frame", "off"]),
+    notes: choice("notes", ["reader", "presenter", "off"]),
+    outcomesFrame: flag("outcomesFrame"),
+    handoutPdf: flag("handoutPdf"),
+    canvas: DECK_CANVAS[aspectRatio]
+  };
+}
+function normalizeReadingMemory(config) {
+  const value = config.readingMemory ?? "ask";
+  if (value !== "ask" && value !== "off") {
+    throw new Error(`CourseConfig readingMemory must be "ask" or "off"; received ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+const APPEARANCE_DEFAULTS = { zones: "tonal", slides: "lifted" };
+const APPEARANCE_ZONES = ["tonal", "accent-header", "paper", "none"];
+const APPEARANCE_SLIDES = ["lifted", "edge", "sorter"];
+function normalizeAppearance(config) {
+  const appearance = config.appearance ?? {};
+  const choice = (field, allowed) => {
+    const value = appearance[field] ?? APPEARANCE_DEFAULTS[field];
+    if (!allowed.includes(value)) {
+      throw new Error(
+        `CourseConfig appearance.${field} must be one of ${allowed.map((v) => `"${v}"`).join(", ")}; received ${JSON.stringify(value)}.`
+      );
+    }
+    return value;
+  };
+  return { zones: choice("zones", APPEARANCE_ZONES), slides: choice("slides", APPEARANCE_SLIDES) };
+}
 function normalizeLessonExports(config) {
   const standaloneHtml = config.lessonExports?.standaloneHtml === true;
   const print = config.lessonExports?.print === true;
@@ -135,13 +229,23 @@ function coursePartsOf(config) {
   return parts;
 }
 export {
+  APPEARANCE_DEFAULTS,
   BLOCK_LABELS_DEFAULT,
   CARDS_DEFAULTS,
+  DECK_CANVAS,
+  DECK_DEFAULTS,
   DISCLOSURE_DEFAULTS,
+  SIDEBAR_EDITIONS_DEFAULTS,
+  SIDEBAR_MARKS_DEFAULTS,
   coursePartsOf,
+  normalizeAppearance,
   normalizeBlockLabels,
   normalizeCards,
+  normalizeDeck,
   normalizeDisclosure,
   normalizeLessonExports,
-  normalizeNumbering
+  normalizeNumbering,
+  normalizeReadingMemory,
+  normalizeSidebarEditions,
+  normalizeSidebarMarks
 };