explico 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -14,6 +14,192 @@ under **Breaking** below; a PATCH never breaks.
 
 ## [Unreleased]
 
+## [0.12.0] - 2026-09-28
+
+### Breaking
+
+- **Every symbol a figure shows opens its notation card, and the build
+  checks it** (rule V3, rule N4). Two checks fail a lab that draws math with
+  KaTeX itself, whose symbols have no card:
+  - **`lab-katex-direct`** (error, rule V3; `reference/lab-katex-validate.ts`,
+    in `diagnostics.figures`): `pnpm validate:content` follows each lesson's
+    relative imports to the course's components and fails a file that
+    imports `katex` (not a type-only import, not the stylesheet), naming the
+    chain of imports that reaches it. V3 now has a check, so it counts as
+    partly enforced.
+  - **`astro build` fails a figure's unbound symbol**: at `astro:build:done`,
+    every letter KaTeX drew inside a `figure.keyed-figure` (its tools
+    included) must sit in a `[data-notation-key]`; upright text
+    (`\text{}`, `\mathrm{}`, a named operator such as `\sin`) is exempt
+    (`reference/figure-symbols.ts`, `assertFigureSymbolsBound`).
+- **`setFigureState` takes no symbol typed as text.** A run is a string or
+  `{ math }`; the italic (`{ text, italic: true }`), plain `{ text }` and
+  subscript (`{ sub }`) runs are gone, and one passed anyway throws, naming
+  the fix. `FigureStateRun` is `string | { math: RenderedLabMath }`, so
+  `astro check` fails an old run.
+- **A page that is not a chapter numbers nothing, and `validate:content` says
+  so** (rule S10, locked). On the landing page, a part's overview page, or
+  any other page outside a part directory, `pnpm validate:content`
+  (`reference/gate-non-chapter-pages.ts`) fails `<Table>`, `<Figure>`,
+  `<Diagram>`, `<CompactExamples>`, `<AssessmentSet>`, a lab (a component
+  imported from a `labs/` module, or any `client:*` island) and
+  `\label{eq:…}` (`non-chapter-float`); `notation.local` and
+  `notation.suspend` (`non-chapter-local-notation`); and `$…$` or `[[…]]` in
+  `hero.title`, `hero.tagline` or a `<PartOverview chain>` step, which print
+  literally (`non-chapter-plain-text`). A `<Diagram>` rendered there
+  unnumbered before, and `<Table>` and `<Figure>` threw at render;
+  `remarkNotation` now fails the same blocks and labels at render, naming
+  S10. Link the chapter's float instead: `[[<chapter>#tab-<key>]]` shows it
+  in its card.
+- **Math on a page that is not a chapter binds like a chapter's** (rule N4,
+  rule S10). Every symbol needs a `[[key]]` or an `\explain` on the page, or
+  the build fails; plain `$v$` on a part page used to render with no card
+  and no check. The text and math gates (rule N4, rule N8, rule N9,
+  rule N10, rule N12, rule N14, rule N22, and a course's `X` rules) and
+  per-place waivers now scan these pages too.
+
+### Added
+
+- **`renderLabMath(template, scope, { display: false })`** renders inline lab
+  math — a `.katex` with no `.katex-display` — for a formula that sits in a
+  line: a legend entry, an axis title, a control label. It never scrolls.
+  `RenderLabMathOptions` is exported; the default stays a display equation.
+- **A `{ math }` run for the caption's live clause.** `setFigureState`
+  writes a `RenderedLabMath` from `renderLabMath(…, { display: false })` as
+  `span.float-caption__math`, so "Shown for v₀ = 20 m/s" names the lesson's
+  own `v₀`, which opens its card.
+- **`unboundFigureSymbols(html)`** (`explico/reference/figure-symbols`) lists
+  the figures in an HTML string, and the symbols in each, that KaTeX drew
+  outside a notation binding. A course's browser test runs it on a hydrated
+  figure's `outerHTML`, which also holds what an island draws only in the
+  browser; the playground's `labs.spec.ts` does.
+- **A link to a chapter shows the chapter's full title as its tooltip.** A
+  Markdown link or a JSX `<a href>` the author wrote to another chapter —
+  root-relative, relative, or under the course's `base`, with or without a
+  `#` anchor — gets the chapter's `title` as its `title` attribute
+  (`remarkNotation`, from the manifest's lessons). A link with a title of its
+  own, a same-page anchor, and a `[[…]]` reference, which opens a card of its
+  own, are left alone.
+- **Cards on a page that is not a chapter** (rule S10). A `[[key]]` term,
+  bound math, a citation, an abbreviation and a `[[chapter#tab-key]]`
+  reference open their cards on the landing page and on a part's overview
+  page: `LessonFooter` mounts the notation, citation, abbreviation and
+  float-reference layers there, from the page's own notation bundle (shared
+  entries only). The manifest schema is now v25: `pages` lists every such
+  page with its `id` (`index`, `motion.index`), `slug`, `file` and a
+  `notation` bundle of the lesson shape, and `notation.bundles` and
+  `notation.backlinks` carry those pages' ids too.
+
+### Changed
+
+- **The operator baseline drops `\limsup` / `\liminf` and the
+  category-theory `\injlim` / `\projlim` / `\varlimsup` / `\varliminf` /
+  `\varinjlim` / `\varprojlim`.** Only `\lim` stays in `BASE_OPERATORS`
+  (`reference/base-operators.mjs`): the other eight are not "everyone knows
+  this" the way a plain limit, `\max`, or `\min` is, so rule N8's
+  `operator-explained` warning now asks a course that uses one for a
+  notation entry, like any other domain operator. A course that relies on
+  the old baseline can restore it with `rules.N8.allow: ['limsup',
+  'liminf', 'injlim', 'projlim', 'varlimsup', 'varliminf', 'varinjlim',
+  'varprojlim']` in its settings.
+- **A lab's math wrapper never scrolls.** `.lab-math` loses its
+  `overflow-x: auto`, `overflow-y: hidden` and `padding-block`: a display
+  template's `.katex-display` scrolls sideways when it is wider than its
+  box, like a lesson equation, and carries the padding. `.lab-math` keeps
+  its `margin-block` only when it holds display math.
+- **A float's caption line is at least as tall as its buttons**
+  (`min-block-size: 1.5rem` while a `.float-tool` shows, reset in print), so
+  the row never hangs below the line — past a figure's body, or into a
+  table's header — even when a course hides the caption's text.
+- **The local-notation mismatch names what it compared.**
+  `assertLocalNotationParity` says "notation mismatch", names the page's
+  frontmatter `notation.local` and the manifest's bundle for the page, and
+  gives both causes left: a stale manifest, or an entry `validate:content`
+  rejected.
+- **`notationDefinitionsForRenderedPage(manifest, pageId, dependencies)`**
+  takes a lesson's id or a non-chapter page's (`manifest.pages[].id`), and
+  its errors say "on page" instead of "in lesson". The `<Table>` and
+  `<Figure>` missing-number errors name rule S10.
+
+### Fixed
+
+- **An abbreviation glossary entry can be scrolled to.** Its anchor
+  (`#abbr-…`) sat on a `display: contents` wrapper, which has no box, so a
+  direct URL, a full navigation and a same-page click all left the reader
+  where they were. The `id` is on the entry's `<dt>`, with the
+  `scroll-margin-block-start: 5rem` the other anchor targets carry.
+- **On a narrow screen, the header no longer covers Starlight's menu
+  button**, so the navigation opens again on a phone: the button sits one
+  level above the raised header (`starlight-menu-button > button`).
+- **Links on a part overview page and in `<CourseContents>` use the course
+  accent** (`--sl-color-text-accent`) instead of the browser's default link
+  colour, which `.not-content` let through.
+- **Printing no longer breaks a knowledge check that hydrates while the page
+  is prepared for print** (React error #418). A collapsed-content note never
+  goes inside an Astro island: a closed disclosure inside one gets its note
+  after the outermost island, once per target URL, so the folded questions
+  of one check share one note after the check.
+- **A `notation.local` entry that a page uses only by shape** — an operator
+  entry `{}'` for `w'`, as rule N22 suggests — **no longer fails the build
+  as a stale manifest.** A page's own local entries seed its notation bundle
+  (`buildNotationRegistry`), so none is `unused-definition` any longer; the
+  `weak-local` advice still names one the page barely uses.
+- **A `lint-ignore.yml` `<detail>` can name a hyphenated notation key.**
+  `parseLintIgnore`'s line grammar excluded `-` from the detail segment, so
+  `- notation-units:arg-min — …` (or any acknowledgement keyed to a
+  kebab-case notation key, the shape every key in a course that follows the
+  authoring docs' own naming convention takes) never matched the line
+  pattern and `validate:content` threw "expected `- <code>[:<detail>] —
+  <reason>`" instead of loading the file. Only whitespace and the em-dash
+  separator are excluded from `<detail>` now; a bare `-`, `--`, or ` - ` was
+  never valid *inside* a detail on its own (the separator needs the em dash,
+  or the ASCII forms flanked the way the grammar already required), so this
+  only admits what the docstring already promised: "a notation key".
+- **A table inside a worked example no longer reports rule S3's
+  `raw-table-markdown`** (or `raw-table-html`): such a table is
+  illustrative, like an equation there. The scan counts a table only where a
+  `<Table>` would number it, at the lesson's top level or in a `<Memo>`,
+  `<ShortNote>` or `<Fold>` (`scanRawFloats`, `collectRawFloats`), as
+  `structure-rules.md#s3` always said.
+- **A `<Table>` or `<Figure>` nested in a worked example fails with the real
+  reason.** `remarkNotation` names the component it sits in and the edit to
+  make, at its line; the components' own guards name the nesting before the
+  Astro configuration.
+- **A figure never draws a vertical scrollbar.** `.keyed-figure__body` kept
+  `overflow-x: auto`, which computes `overflow-y` to `auto` as well, so a
+  fractional height at a browser zoom scrolled by a pixel; it now clips
+  vertically (`overflow-y: hidden`).
+- **A display equation that just fits no longer scrolls by 2 px.** KaTeX's
+  stacked scripts hang a 2 px spacer outside their box; `.katex-display` (in
+  lesson content and in `.lab-math`) reserves it with `padding-inline: 2px`
+  on both sides, which keeps a centred equation centred.
+- **A `[[key]]` or an `\explain` on a part overview page no longer fails
+  `astro build` after `validate:content` passed.** The page had no notation
+  entries, so the payload invariant found a trigger with no card. Rule S2's
+  "its math and `[[key]]` references render" now holds.
+- **An indented `[[key]]` inside a component of an `.mdx` page reaches the
+  page's bundle.** The reference extractor masked a line indented by four
+  spaces as an indented code block, which MDX does not have, so text
+  indented inside `<Card>` or `<Memo>` rendered a trigger its bundle lacked,
+  and the build failed. A `.md` file keeps CommonMark's indented code.
+
+## [0.11.1] - 2026-09-28
+
+### Fixed
+
+- **A side panel's labels wrap instead of scrolling sideways.** A chapter,
+  lesson or heading longer than the navigation or the "On this page" panel
+  is wide goes onto more lines, at any width, including one the reader
+  dragged a panel down to; a word longer than the panel hyphenates where the
+  language allows, else breaks. A resized panel used to keep each label on
+  one line and scroll sideways (`white-space: nowrap` on
+  `html[data-navigation-resized]` / `html[data-contents-resized]`), and the
+  "On this page" column kept a width taken from the navigation's
+  (`--sl-sidebar-width`), running past a narrowed panel's edge; it now fills
+  its panel. `.sidebar-pane` clips sideways (`overflow-x: hidden`), where a
+  compact chapter's invisible resting tooltip reached past it; a showing
+  tooltip is `position: fixed` and is never cut.
+
 ## [0.11.0] - 2026-09-28
 
 ### Breaking
@@ -2126,7 +2312,9 @@ under **Breaking** below; a PATCH never breaks.
   system with its completeness gate, the curriculum-graph validator, the
   Astro/Starlight UI, the LMS / session / analytics seams, and the `content` CLI.
 
-[Unreleased]: https://github.com/danieltuzes/explico/compare/v0.11.0...HEAD
+[Unreleased]: https://github.com/danieltuzes/explico/compare/v0.12.0...HEAD
+[0.12.0]: https://github.com/danieltuzes/explico/compare/v0.11.1...v0.12.0
+[0.11.1]: https://github.com/danieltuzes/explico/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/danieltuzes/explico/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/danieltuzes/explico/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/danieltuzes/explico/compare/v0.8.0...v0.9.0

package/dist/compiler/astro.d.ts

@@ -17,6 +17,7 @@ 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';
@@ -26,7 +27,12 @@ import './lesson-derivation.js';
 
 /** Match only a configured lesson artifact below Astro's deployment base. */
 declare function matchStandaloneDownload(pathname: string, base: string, lessonSlugs: readonly string[]): string | undefined;
-/** Fail loudly instead of rendering math triggers whose local cards are stale. */
+/**
+ * Fail loudly instead of rendering math triggers whose local cards are
+ * missing. The manifest bundles every `notation.local` entry with its page,
+ * so the two lists differ only when the manifest is older than the page, or
+ * when `validate:content` rejected an entry.
+ */
 declare function assertLocalNotationParity(lessonId: string, authoredKeys: readonly string[], renderedKeys: readonly string[]): void;
 /** Fail an Astro build if final rendered HTML contains an unusable trigger. */
 declare function assertNotationPayloadHtml(page: string, html: string): void;

package/dist/compiler/astro.js

@@ -8,6 +8,7 @@ import {
   writeManifest
 } from "./manifest.js";
 import { missingNotationPayloadKeys } from "../reference/page-notation.js";
+import { assertFigureSymbolsBound } from "../reference/figure-symbols.js";
 import { writeStandaloneLessonExports } from "./exports/standalone-html.js";
 import remarkAbbreviations from "../reference/remark-abbreviations.mjs";
 import remarkCitation from "../reference/remark-citation.mjs";
@@ -87,7 +88,7 @@ function assertLocalNotationParity(lessonId, authoredKeys, renderedKeys) {
     return;
   }
   throw new Error(
-    `Stale Explico manifest for ${lessonId}: lesson notation.local has [${authored.join(", ")}], but the page notation bundle has [${rendered.join(", ")}]. Pass courseConfig to loadManifest() and add explicoContentRefresh() to the Astro integrations.`
+    `Explico notation mismatch for ${lessonId}: the page's frontmatter notation.local declares [${authored.join(", ")}], but the manifest's notation bundle for the page holds [${rendered.join(", ")}]. The manifest bundles every notation.local entry with its page, so either it is stale \u2014 pass courseConfig to loadManifest() and add explicoContentRefresh() to the Astro integrations \u2014 or \`pnpm validate:content\` rejected an entry: fix the errors it reports.`
   );
 }
 function assertNotationPayloadHtml(page, html) {
@@ -139,7 +140,9 @@ async function validateGeneratedNotationPayloads(directory) {
       if (entry.isDirectory()) {
         await walk(child);
       } else if (entry.isFile() && entry.name.endsWith(".html")) {
-        assertNotationPayloadHtml(relative(root, child), await readFile(child, "utf8"));
+        const html = await readFile(child, "utf8");
+        assertNotationPayloadHtml(relative(root, child), html);
+        assertFigureSymbolsBound(relative(root, child), html);
       }
     }
   };

package/dist/compiler/cli.d.ts

@@ -18,6 +18,7 @@ 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';

package/dist/compiler/collections.d.ts

@@ -1,5 +1,5 @@
 import { CurriculumCatalog } from '../curriculum/validation.js';
-import { NotationReferenceInput, AbbreviationDefinitionInput, NotationRegistryInput, LocalNotationDefinitionInput, NotationSuspension } from '../reference/types.js';
+import { NotationLessonInput, NotationReferenceInput, AbbreviationDefinitionInput, NotationRegistryInput, LocalNotationDefinitionInput, NotationSuspension } from '../reference/types.js';
 
 /**
  * The single path from content files to typed data.
@@ -54,6 +54,29 @@ 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 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
+ * `isLessonSlug` rejects. Such a page may explain its symbols like a chapter,
+ * but it recalls them only: it takes no `notation.local` and no float numbers.
+ */
+interface NonChapterPage {
+    /** `lessonIdFromSlug(slug)` — `index`, `motion.index`, `glossary`. Never a lesson id. */
+    readonly id: string;
+    /** Docs slug without extension, e.g. `motion/index`. */
+    readonly slug: string;
+    readonly file: string;
+    readonly data: Record<string, unknown>;
+    readonly body: string;
+    readonly bodyLine: number;
+    /**
+     * The page as notation input — no local entries, no suspensions — so the
+     * registry resolves its `[[key]]` references and the text and math gates
+     * scan it exactly as they scan a chapter.
+     */
+    readonly notation: NotationLessonInput;
+}
+declare function loadNonChapterPages(): NonChapterPage[];
 declare function loadNotationRegistryInput(): Promise<NotationRegistryInput>;
 /**
  * Notation frontmatter objects for `remark-notation`'s `definitions` option.
@@ -101,4 +124,4 @@ declare function notationSourceLocatorGaps(): {
     total: number;
 };
 
-export { type NotationSpec, type PartOverviewPage, extractNotationReferences, loadAbbreviationRegistryInput, loadCurriculumCatalog, loadLessonChecks, loadNotationDefinitions, loadNotationRegistryInput, loadNotationSpecs, loadPartOverviews, loadSourceRecords, notationSourceLocatorGaps, notationSuspensions };
+export { type NonChapterPage, type NotationSpec, type PartOverviewPage, extractNotationReferences, loadAbbreviationRegistryInput, loadCurriculumCatalog, loadLessonChecks, loadNonChapterPages, loadNotationDefinitions, loadNotationRegistryInput, loadNotationSpecs, loadPartOverviews, loadSourceRecords, notationSourceLocatorGaps, notationSuspensions };

package/dist/compiler/collections.js

@@ -139,16 +139,20 @@ function sourceSpan(file, text, index) {
     column: (lines.at(-1)?.length ?? 0) + 1
   };
 }
-function maskMarkdownLiterals(text) {
+function maskMarkdownLiterals(text, mdx) {
   const mask = (value) => value.replace(/[^\n]/g, " ");
-  return text.replace(
+  const fenced = text.replace(
     /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?(?:\n[ \t]{0,3}\2[^\n]*(?=\n|$)|$)/g,
     mask
-  ).replace(/^(?: {4}|\t).*$/gm, mask).replace(/(`+)(?!`)([^\n]*?)\1/g, mask);
+  );
+  return (mdx ? fenced : fenced.replace(/^(?: {4}|\t).*$/gm, mask)).replace(
+    /(`+)(?!`)([^\n]*?)\1/g,
+    mask
+  );
 }
 function extractNotationReferences(text, file, kind) {
   const references = [];
-  const searchable = maskMarkdownLiterals(text);
+  const searchable = maskMarkdownLiterals(text, file.endsWith(".mdx"));
   const patterns = [
     [/\[\[\s*([^\][]+?)\s*\]\]/g, kind ?? "prose"],
     [/\\explain\{([^{}]+)\}/g, kind ?? "math"]
@@ -412,6 +416,34 @@ function notationLessonEntries() {
   }
   return lessons;
 }
+function loadNonChapterPages() {
+  const pages = [];
+  for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
+    const slug = docSlug(path);
+    if (isLessonSlug(slug)) continue;
+    const { file, data, body, bodyLine } = parseDocument(path);
+    const id = lessonIdFromSlug(slug);
+    pages.push({
+      id,
+      slug: slug.replace(/\.(md|mdx)$/, ""),
+      file,
+      data,
+      body,
+      bodyLine,
+      notation: {
+        lessonId: id,
+        status: status(data.editorialStatus ?? "draft", `${file} editorialStatus`),
+        localDefinitions: [],
+        suspended: [],
+        references: extractNotationReferences(body, file, void 0),
+        body,
+        bodyLine,
+        source: { file }
+      }
+    });
+  }
+  return pages;
+}
 async function loadNotationRegistryInput() {
   return {
     sharedDefinitions: sharedNotationEntries(),
@@ -506,6 +538,7 @@ export {
   loadAbbreviationRegistryInput,
   loadCurriculumCatalog,
   loadLessonChecks,
+  loadNonChapterPages,
   loadNotationDefinitions,
   loadNotationRegistryInput,
   loadNotationSpecs,

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

@@ -16,6 +16,7 @@ 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';

package/dist/compiler/manifest.d.ts

@@ -8,6 +8,7 @@ import { ExampleLabelRecord, ExampleDiagnostic } from '../reference/examples-val
 import { FoldDiagnostic } from '../reference/folds-validate.js';
 import { KnowledgeCheckLabelRecord, KnowledgeCheckDiagnostic } from '../reference/knowledge-checks-validate.js';
 import { RawFloatDiagnostic } from '../reference/raw-floats-validate.js';
+import { LabKatexDiagnostic } from '../reference/lab-katex-validate.js';
 import { MathGateDiagnostic } from '../reference/gate-math.js';
 import { ContentSegment } from '../reference/mixed-content.js';
 import { GlyphScopeEntry } from '../reference/gloss.js';
@@ -167,8 +168,14 @@ import '../rules/course-rules.js';
  * state of a `<Fold>`; `disclosure.figures` now says whether a lab's tools
  * start open; `diagnostics.folds` holds `fold-unnamed`
  * (docs/plans/figures-and-short-captions.md, Parts 1–2).
+ *
+ * v25 (cards on non-chapter pages, rule S10): `pages` — every docs page that
+ * is not a chapter (the landing page, a part's overview page, …) with its
+ * `id`, `slug`, `file` and a `notation` bundle of the lesson shape, so the
+ * footer renders the cards its `[[key]]` terms and math open.
+ * `notation.bundles` and `notation.backlinks` now carry those pages' ids too.
  */
-declare const MANIFEST_SCHEMA_VERSION = 24;
+declare const MANIFEST_SCHEMA_VERSION = 25;
 declare const MANIFEST_PATH: string;
 interface ManifestCitation {
     readonly id: string;
@@ -340,6 +347,19 @@ interface ManifestLesson {
         readonly resolution: readonly ManifestNotationResolution[];
     };
 }
+/**
+ * A docs page that is not a chapter (v25, rule S10) — the landing page, a
+ * part's overview page, any page outside a part directory. It numbers
+ * nothing, so it carries only what its cards need: the notation bundle its
+ * `[[key]]` terms and math reach, shared entries only.
+ */
+interface ManifestPage {
+    /** `index`, `motion.index`, `glossary` — `lessonIdFromSlug` of the slug; never a lesson id. */
+    readonly id: string;
+    readonly slug: string;
+    readonly file: string;
+    readonly notation: ManifestLesson['notation'];
+}
 /** The reader-facing "about this material" bundle — the `[?]` panel's data. */
 interface ManifestAbout {
     /** `explico`'s own identity, from its `package.json` (the version's golden source). */
@@ -438,6 +458,8 @@ interface Manifest {
     /** The course's parts in config order, with their chapters and overview pages. */
     readonly parts: readonly ManifestPart[];
     readonly lessons: readonly ManifestLesson[];
+    /** Every docs page that is not a chapter, by id (v25). */
+    readonly pages: readonly ManifestPage[];
     /** Full competency prerequisite graph. */
     readonly prereqEdges: readonly PrereqEdge[];
     /** Equation identity (D7): every labelled display equation + the render-path lookup. */
@@ -501,8 +523,12 @@ interface Manifest {
         readonly equations: readonly EquationDiagnostic[];
         /** `<Table>` identity checks (F-tables-figures) — same codes, `tab-` prefixed. */
         readonly tables: readonly TableDiagnostic[];
-        /** `<Figure>` identity checks (F-tables-figures) — same codes, `fig-` prefixed. */
-        readonly figures: readonly FigureDiagnostic[];
+        /**
+         * `<Figure>` identity checks (F-tables-figures) — same codes, `fig-`
+         * prefixed — and rule V3's `lab-katex-direct`: a file a lesson imports
+         * that calls KaTeX itself.
+         */
+        readonly figures: readonly (FigureDiagnostic | LabKatexDiagnostic)[];
         /** `<Diagram>` identity checks — same codes, `dia-` prefixed. */
         readonly diagrams: readonly DiagramDiagnostic[];
         /** Knowledge-check identity and `[[check-…]]` reference checks. */
@@ -549,4 +575,4 @@ declare function readManifestSync(): Manifest;
  */
 declare function loadManifest(courseConfig?: CourseConfig): Promise<Manifest>;
 
-export { MANIFEST_PATH, MANIFEST_SCHEMA_VERSION, type Manifest, type ManifestAbout, type ManifestAssessmentItemContent, type ManifestCitation, type ManifestLesson, type ManifestLessonFloat, type ManifestLessonNotation, type ManifestNotationResolution, type ManifestPart, type ManifestTitledBlock, type PrereqEdge, compileManifest, loadManifest, readManifestSync, serializeManifest, writeManifest };
+export { MANIFEST_PATH, MANIFEST_SCHEMA_VERSION, type Manifest, type ManifestAbout, type ManifestAssessmentItemContent, type ManifestCitation, type ManifestLesson, type ManifestLessonFloat, type ManifestLessonNotation, type ManifestNotationResolution, type ManifestPage, type ManifestPart, type ManifestTitledBlock, type PrereqEdge, compileManifest, loadManifest, readManifestSync, serializeManifest, writeManifest };

package/dist/compiler/manifest.js

@@ -40,6 +40,9 @@ import {
 import {
   validateRawFloats
 } from "../reference/raw-floats-validate.js";
+import {
+  validateLabKatexImports
+} from "../reference/lab-katex-validate.js";
 import {
   gateContentMath,
   pageScope
@@ -57,6 +60,7 @@ import { gateCourseRules } from "../reference/gate-course-rules.js";
 import { gateHeadingLength } from "../reference/gate-heading-length.js";
 import { gateHeadingStructure } from "../reference/gate-heading-structure.js";
 import { gatePartPages } from "../reference/gate-part-pages.js";
+import { gateNonChapterPages } from "../reference/gate-non-chapter-pages.js";
 import {
   scanSectionHeadings,
   scanTitledBlocks
@@ -96,6 +100,7 @@ import {
   loadCurriculumCatalog,
   loadNotationDefinitions,
   loadNotationRegistryInput,
+  loadNonChapterPages,
   loadNotationSpecs,
   loadPartOverviews,
   loadSourceRecords
@@ -106,7 +111,7 @@ import {
   isLessonSlug,
   lessonIdFromSlug
 } from "./lesson-derivation.js";
-const MANIFEST_SCHEMA_VERSION = 24;
+const MANIFEST_SCHEMA_VERSION = 25;
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
 const MANIFEST_PATH = join(REPOSITORY_ROOT, "build", "manifest.json");
@@ -260,7 +265,15 @@ async function compileManifest(courseConfig) {
     loadNotationRegistryInput(),
     loadAbbreviationRegistryInput()
   ]);
-  const registry = buildNotationRegistry(notationInput);
+  const nonChapterPages = loadNonChapterPages();
+  const withPages = {
+    ...notationInput,
+    lessons: [
+      ...notationInput.lessons,
+      ...nonChapterPages.map((page) => page.notation)
+    ]
+  };
+  const registry = buildNotationRegistry(withPages);
   const cardsByKey = new Map(
     notationInput.sharedDefinitions.map((definition) => [
       definition.key,
@@ -283,7 +296,7 @@ async function compileManifest(courseConfig) {
   };
   const mathIssues = [
     ...gateContentMath({
-      notationInput,
+      notationInput: withPages,
       assessments: assessmentsInput,
       lessonAssessments: catalog.lessons.map((lesson) => ({
         lessonId: lesson.id,
@@ -291,7 +304,7 @@ async function compileManifest(courseConfig) {
       }))
     }),
     ...rules.isEnabled("N9") ? [
-      ...gateProseNotation(notationInput.lessons, {
+      ...gateProseNotation(withPages.lessons, {
         allowSpelledUnits: rules.strings("N9", "allow")
       }),
       ...gateProseNotationInAssessments(assessmentsInput, {
@@ -299,11 +312,11 @@ async function compileManifest(courseConfig) {
       })
     ] : [],
     ...rules.isEnabled("N12") ? [
-      ...gateMathPunctuation(notationInput.lessons, mathEndAbbreviations),
+      ...gateMathPunctuation(withPages.lessons, mathEndAbbreviations),
       ...gateMathPunctuationInAssessments(assessmentsInput, mathEndAbbreviations)
     ] : [],
     ...rules.isEnabled("N14") ? gateAbbreviations({
-      notationInput,
+      notationInput: withPages,
       abbreviations: abbreviationsInput,
       courseAbbreviations: rules.settings("N14")
     }) : [],
@@ -317,7 +330,9 @@ async function compileManifest(courseConfig) {
     // The course's own rules (`courseRules`): one pass for every enabled `X`
     // rule that carries a `forbid` pattern. A disabled one, and a guide rule
     // with no pattern, do no work here.
-    ...gateCourseRules(notationInput.lessons, rules.course)
+    ...gateCourseRules(withPages.lessons, rules.course),
+    // S10 is locked: a float on a non-chapter page has no number to render.
+    ...gateNonChapterPages(nonChapterPages)
   ];
   const notationLessonById = new Map(
     notationInput.lessons.map((lesson) => [lesson.lessonId, lesson])
@@ -381,7 +396,7 @@ async function compileManifest(courseConfig) {
   }
   const waiverDiagnostics = [];
   const waiverRules = { courseRules: rules.course };
-  const waivers = notationInput.lessons.flatMap((lesson) => {
+  const waivers = withPages.lessons.flatMap((lesson) => {
     const collected = collectWaivers(lesson, waiverRules);
     waiverDiagnostics.push(...collected.diagnostics);
     return collected.waivers;
@@ -593,6 +608,14 @@ async function compileManifest(courseConfig) {
       }
     );
   };
+  const labKatexDiagnostics = validateLabKatexImports(
+    notationInput.lessons.map((lesson) => ({
+      lessonId: lesson.lessonId,
+      file: lesson.source.file,
+      body: lesson.body
+    })),
+    REPOSITORY_ROOT
+  );
   const rawFloatDiagnostics = validateRawFloats(
     notationInput.lessons.map((lesson) => ({
       lessonId: lesson.lessonId,
@@ -665,9 +688,24 @@ async function compileManifest(courseConfig) {
     });
   }
   lessons.sort((a, b) => a.id.localeCompare(b.id));
+  const pages = nonChapterPages.map((page) => ({
+    id: page.id,
+    slug: page.slug,
+    file: page.file,
+    notation: lessonNotationBundle(
+      bundlesByLesson.get(page.id),
+      definitionsById,
+      lessonNotationResolution(
+        page.notation,
+        definitionsById,
+        availableDefinitionIds
+      ),
+      cardsByKey
+    )
+  })).sort((a, b) => a.id.localeCompare(b.id));
   const consistencyIssues = runConsistencyChecks({
     registry,
-    notationInput,
+    notationInput: withPages,
     specs: loadNotationSpecs(),
     catalog,
     lintIgnore: loadLintIgnore(),
@@ -741,6 +779,7 @@ async function compileManifest(courseConfig) {
     sidebar,
     parts: manifestParts,
     lessons,
+    pages,
     prereqEdges,
     equations: {
       labels: equationValidation.labels,
@@ -776,7 +815,7 @@ async function compileManifest(courseConfig) {
       consistency: dropDisabled(consistencyIssues, off),
       equations: dropDisabled(equationValidation.diagnostics, off),
       tables: dropDisabled(tableValidation.diagnostics, off),
-      figures: dropDisabled(figureValidation.diagnostics, off),
+      figures: dropDisabled([...figureValidation.diagnostics, ...labKatexDiagnostics], off),
       diagrams: dropDisabled(diagramValidation.diagnostics, off),
       checks: dropDisabled(checkValidation.diagnostics, off),
       examples: dropDisabled(exampleValidation.diagnostics, off),

package/dist/compiler/resolution-report.d.ts

@@ -16,6 +16,7 @@ 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';

package/dist/reference/base-operators.d.mts

@@ -26,6 +26,12 @@ export function isBaseOperator(name: any, operators: any): boolean;
  * baseline — trig, the exponential and logarithms, limits, extrema, and the
  * big operators — kept greppable and small like the base library.
  *
+ * Only the plain limit, `\lim`, is baseline. `\limsup` / `\liminf` and the
+ * category-theory `\injlim` / `\projlim` / `\varlimsup` / `\varliminf` /
+ * `\varinjlim` / `\varprojlim` read fine to someone who already knows them,
+ * but none is "everyone knows this" the way `\lim` or `\max` is — a course
+ * that uses one owes it a notation entry, like any other domain operator.
+ *
  * A domain operator (`Var`, `Cov`, `Corr`, `sgn`, `erf`, `Tr`, `argmax`, …) is
  * written `\operatorname{…}` and is NOT here: it earns a card, a
  * `notation.local` entry, or an explicit line in `course.config.ts`