explico 0.3.0 → 0.4.0

package/dist/reference/equations.d.mts

@@ -9,12 +9,28 @@ export function parseEquationRef(raw: any): {
 /** Remove every `\label{eq:…}` (and the whitespace it leaves) from a math source. */
 export function stripEquationLabels(latex: any): string;
 /**
- * The visible number for one display equation. With `chapter` (the lesson's
- * course ordinal) the scheme is `‹chapter›.‹indexInLesson›` and `##` headings
+ * Normalise the numbering input to `{ prefix, offset }`.
+ *
+ * `prefix` is the number before the dot — the **part**'s ordinal (its position
+ * among the sidebar groups). `offset` is how many display equations already
+ * appeared in earlier lessons of that same part, so `n` runs continuously
+ * across a part instead of restarting on every page. A bare number is the
+ * legacy per-lesson form (`prefix = n`, `offset = 0`) and is still accepted so
+ * hand-built trees and unit tests keep working. `undefined`/`null`/`0` ⇒ the
+ * `##`-section fallback for non-lesson pages.
+ */
+export function resolveNumbering(input: any): {
+    prefix: any;
+    offset: number;
+};
+/**
+ * The visible number for one display equation. With a `prefix` (the part's
+ * ordinal) the scheme is `‹part›.‹offset + indexInLesson›` and `##` headings
  * are ignored; without it, the legacy `##`-section scheme.
  */
-export function displayEquationNumber({ chapter, section, indexInSection, indexInLesson, }: {
-    chapter: any;
+export function displayEquationNumber({ prefix, offset, section, indexInSection, indexInLesson, }: {
+    prefix: any;
+    offset?: number | undefined;
     section: any;
     indexInSection: any;
     indexInLesson: any;
@@ -38,28 +54,43 @@ export function stripFencedCode(markdown: any): string;
  */
 export function stripJsxComponents(markdown: any, keep: any): string;
 /**
- * Every keyed display equation in a Markdown body, in appearance order, with
- * its assigned number. `$$…$$` blocks only. With `chapter` (the lesson's
- * course ordinal) the number is `‹chapter›.‹n›`, `n` sequential over every
- * display block in the lesson; without it, `##` headings advance a section
- * counter and the number is `‹section›.‹indexInSection›`. Either way every
- * display block advances the index, so a keyed equation's number reflects its
- * position among *all* display equations, not only the keyed ones.
+ * Every display equation in a Markdown body, keyed or not, in appearance order
+ * with its assigned number. `$$…$$` blocks only. With `numbering`
+ * (`{ prefix, offset }`, the part's ordinal and the count of display equations
+ * in earlier lessons of that part) the number is `‹part›.‹offset + n›`, `n`
+ * sequential over every display block in the lesson; without it, `##` headings
+ * advance a section counter and the number is `‹section›.‹indexInSection›`.
+ * Either way every display block advances the index, so a keyed equation's
+ * number reflects its position among *all* display equations, not only the
+ * keyed ones.
  */
-export function scanEquationLabels(markdown: any, chapter: any): {
-    key: string;
+export function scanDisplayEquations(markdown: any, numbering: any): {
+    key: string | null | undefined;
+    number: string;
+    section: number;
+    indexInSection: number;
+}[];
+/** The keyed subset of `scanDisplayEquations` — the manifest builder's view. */
+export function scanEquationLabels(markdown: any, numbering: any): {
+    key: string | null | undefined;
     number: string;
     section: number;
     indexInSection: number;
 }[];
+/**
+ * How many display equations a lesson body holds. This is what makes `n` run
+ * continuously across a part: a lesson's `offset` is the sum of this over every
+ * earlier lesson in the same part.
+ */
+export function countDisplayEquations(markdown: any): number;
 /**
  * The mdast equivalent of `scanEquationLabels` for *every* display equation:
  * walk the tree in document order, advancing the section counter on every
  * depth-2 heading and emitting a record for every `math` node. `key` is the
- * `\label{eq:…}` payload when present, else `null`. `chapter` is threaded the
+ * `\label{eq:…}` payload when present, else `null`. `numbering` is threaded the
  * same way as in `scanEquationLabels`.
  */
-export function collectDisplayEquations(tree: any, chapter: any): {
+export function collectDisplayEquations(tree: any, numbering: any): {
     key: string | null;
     number: string;
     section: number;
@@ -70,7 +101,7 @@ export function collectDisplayEquations(tree: any, chapter: any): {
  * The keyed subset of `collectDisplayEquations` — the tree-walk counterpart of
  * `scanEquationLabels`. Numbers reflect position among all display equations.
  */
-export function collectEquationLabels(tree: any, chapter: any): {
+export function collectEquationLabels(tree: any, numbering: any): {
     key: string | null;
     number: string;
     section: number;
@@ -81,12 +112,17 @@ export function collectEquationLabels(tree: any, chapter: any): {
  * Equation identity (Step D7, extended F3) — shared, framework-free helpers.
  *
  * Every display equation (`$$…$$`) in a lesson is numbered and given an `id`
- * from appearance order. When the caller supplies a `chapter` (the lesson's
- * ordinal position in the course), the number is `‹chapter›.‹n›` — `n` counts
- * every display equation in the lesson and `##` headings do not affect it
- * (`(2.4)` = fourth display equation of the second lesson). With no `chapter`
- * the number falls back to the `##`-section scheme `‹section›.‹indexInSection›`
- * (used by hand-built test trees and non-lesson pages). An author additionally
+ * from appearance order. When the caller supplies `numbering`
+ * (`{ prefix, offset }` — see `resolveNumbering`), the number is
+ * `‹part›.‹offset + n›`: the prefix is the **part**'s ordinal among the sidebar
+ * groups, `n` counts every display equation in the lesson, and `offset` carries
+ * the count from earlier lessons of the same part so the sequence runs
+ * continuously across a part rather than restarting on every page. `##` and
+ * `###` headings never affect it — `(2.4)` is the fourth display equation of
+ * part 2, wherever in that part it sits. See `docs/authoring/structure.md` for
+ * the level names. With no `numbering` the number falls back to the
+ * `##`-section scheme `‹section›.‹indexInSection›` (used by hand-built test
+ * trees and non-lesson pages). An author additionally
  * marks an equation with a trailing `\label{eq:<key>}` inside its `$$…$$`
  * block (inside math, so the `:` is safe and the form matches amsmath) when
  * they want a *stable* anchor that survives edits and cross-page references:

package/dist/reference/equations.mjs

@@ -2,12 +2,17 @@
  * Equation identity (Step D7, extended F3) — shared, framework-free helpers.
  *
  * Every display equation (`$$…$$`) in a lesson is numbered and given an `id`
- * from appearance order. When the caller supplies a `chapter` (the lesson's
- * ordinal position in the course), the number is `‹chapter›.‹n›` — `n` counts
- * every display equation in the lesson and `##` headings do not affect it
- * (`(2.4)` = fourth display equation of the second lesson). With no `chapter`
- * the number falls back to the `##`-section scheme `‹section›.‹indexInSection›`
- * (used by hand-built test trees and non-lesson pages). An author additionally
+ * from appearance order. When the caller supplies `numbering`
+ * (`{ prefix, offset }` — see `resolveNumbering`), the number is
+ * `‹part›.‹offset + n›`: the prefix is the **part**'s ordinal among the sidebar
+ * groups, `n` counts every display equation in the lesson, and `offset` carries
+ * the count from earlier lessons of the same part so the sequence runs
+ * continuously across a part rather than restarting on every page. `##` and
+ * `###` headings never affect it — `(2.4)` is the fourth display equation of
+ * part 2, wherever in that part it sits. See `docs/authoring/structure.md` for
+ * the level names. With no `numbering` the number falls back to the
+ * `##`-section scheme `‹section›.‹indexInSection›` (used by hand-built test
+ * trees and non-lesson pages). An author additionally
  * marks an equation with a trailing `\label{eq:<key>}` inside its `$$…$$`
  * block (inside math, so the `:` is safe and the form matches amsmath) when
  * they want a *stable* anchor that survives edits and cross-page references:
@@ -63,19 +68,42 @@ function equationNumber(section, index) {
 }
 
 /**
- * The visible number for one display equation. With `chapter` (the lesson's
- * course ordinal) the scheme is `‹chapter›.‹indexInLesson›` and `##` headings
+ * Normalise the numbering input to `{ prefix, offset }`.
+ *
+ * `prefix` is the number before the dot — the **part**'s ordinal (its position
+ * among the sidebar groups). `offset` is how many display equations already
+ * appeared in earlier lessons of that same part, so `n` runs continuously
+ * across a part instead of restarting on every page. A bare number is the
+ * legacy per-lesson form (`prefix = n`, `offset = 0`) and is still accepted so
+ * hand-built trees and unit tests keep working. `undefined`/`null`/`0` ⇒ the
+ * `##`-section fallback for non-lesson pages.
+ */
+export function resolveNumbering(input) {
+  if (input == null) return { prefix: undefined, offset: 0 };
+  if (typeof input === 'number') {
+    return { prefix: input || undefined, offset: 0 };
+  }
+  return {
+    prefix: input.prefix || undefined,
+    offset: Number(input.offset) || 0,
+  };
+}
+
+/**
+ * The visible number for one display equation. With a `prefix` (the part's
+ * ordinal) the scheme is `‹part›.‹offset + indexInLesson›` and `##` headings
  * are ignored; without it, the legacy `##`-section scheme.
  */
 export function displayEquationNumber({
-  chapter,
+  prefix,
+  offset = 0,
   section,
   indexInSection,
   indexInLesson,
 }) {
-  return chapter == null
+  return prefix == null
     ? equationNumber(section, indexInSection)
-    : `${chapter}.${indexInLesson}`;
+    : `${prefix}.${offset + indexInLesson}`;
 }
 
 /** The positional anchor id for an unkeyed equation, e.g. `2.4` → `eq-2-4`. */
@@ -109,15 +137,18 @@ export function stripJsxComponents(markdown, keep) {
 }
 
 /**
- * Every keyed display equation in a Markdown body, in appearance order, with
- * its assigned number. `$$…$$` blocks only. With `chapter` (the lesson's
- * course ordinal) the number is `‹chapter›.‹n›`, `n` sequential over every
- * display block in the lesson; without it, `##` headings advance a section
- * counter and the number is `‹section›.‹indexInSection›`. Either way every
- * display block advances the index, so a keyed equation's number reflects its
- * position among *all* display equations, not only the keyed ones.
+ * Every display equation in a Markdown body, keyed or not, in appearance order
+ * with its assigned number. `$$…$$` blocks only. With `numbering`
+ * (`{ prefix, offset }`, the part's ordinal and the count of display equations
+ * in earlier lessons of that part) the number is `‹part›.‹offset + n›`, `n`
+ * sequential over every display block in the lesson; without it, `##` headings
+ * advance a section counter and the number is `‹section›.‹indexInSection›`.
+ * Either way every display block advances the index, so a keyed equation's
+ * number reflects its position among *all* display equations, not only the
+ * keyed ones.
  */
-export function scanEquationLabels(markdown, chapter) {
+export function scanDisplayEquations(markdown, numbering) {
+  const { prefix, offset } = resolveNumbering(numbering);
   const text = stripJsxComponents(stripFencedCode(markdown));
   const tokens = [];
   const heading = /^[ \t]{0,3}##[ \t]+\S/gm;
@@ -148,11 +179,11 @@ export function scanEquationLabels(markdown, chapter) {
     }
     indexInSection += 1;
     indexInLesson += 1;
-    if (token.key == null) continue;
     labels.push({
       key: token.key,
       number: displayEquationNumber({
-        chapter,
+        prefix,
+        offset,
         section,
         indexInSection,
         indexInLesson,
@@ -164,14 +195,31 @@ export function scanEquationLabels(markdown, chapter) {
   return labels;
 }
 
+/** The keyed subset of `scanDisplayEquations` — the manifest builder's view. */
+export function scanEquationLabels(markdown, numbering) {
+  return scanDisplayEquations(markdown, numbering).filter(
+    (equation) => equation.key != null,
+  );
+}
+
+/**
+ * How many display equations a lesson body holds. This is what makes `n` run
+ * continuously across a part: a lesson's `offset` is the sum of this over every
+ * earlier lesson in the same part.
+ */
+export function countDisplayEquations(markdown) {
+  return scanDisplayEquations(markdown).length;
+}
+
 /**
  * The mdast equivalent of `scanEquationLabels` for *every* display equation:
  * walk the tree in document order, advancing the section counter on every
  * depth-2 heading and emitting a record for every `math` node. `key` is the
- * `\label{eq:…}` payload when present, else `null`. `chapter` is threaded the
+ * `\label{eq:…}` payload when present, else `null`. `numbering` is threaded the
  * same way as in `scanEquationLabels`.
  */
-export function collectDisplayEquations(tree, chapter) {
+export function collectDisplayEquations(tree, numbering) {
+  const { prefix, offset } = resolveNumbering(numbering);
   const equations = [];
   let section = 0;
   let indexInSection = 0;
@@ -196,7 +244,8 @@ export function collectDisplayEquations(tree, chapter) {
       equations.push({
         key: label ? label[1] : null,
         number: displayEquationNumber({
-          chapter,
+          prefix,
+          offset,
           section,
           indexInSection,
           indexInLesson,
@@ -214,8 +263,8 @@ export function collectDisplayEquations(tree, chapter) {
  * The keyed subset of `collectDisplayEquations` — the tree-walk counterpart of
  * `scanEquationLabels`. Numbers reflect position among all display equations.
  */
-export function collectEquationLabels(tree, chapter) {
-  return collectDisplayEquations(tree, chapter).filter(
+export function collectEquationLabels(tree, numbering) {
+  return collectDisplayEquations(tree, numbering).filter(
     (equation) => equation.key != null,
   );
 }

package/dist/reference/keyed-float-validate.d.ts

@@ -57,10 +57,16 @@ interface KeyedFloatLessonInput {
     readonly file: string;
     readonly body: string;
     /**
-     * The lesson's 1-based ordinal in the course. When set, floats are numbered
-     * `‹chapter›.‹n›`; when omitted, the legacy `##`-section scheme.
+     * `{ prefix, offset }` — the part's 1-based ordinal among the sidebar groups,
+     * and how many floats of this kind earlier lessons of that part already used.
+     * When set, floats are numbered `‹part›.‹offset + n›`; when omitted, the
+     * legacy `##`-section scheme. Each kind counts on its own, so the caller
+     * passes a different `offset` for `<Table>` than for `<Figure>`.
      */
-    readonly chapter?: number;
+    readonly numbering?: {
+        readonly prefix: number;
+        readonly offset: number;
+    };
 }
 declare function validateKeyedFloats(lessons: readonly KeyedFloatLessonInput[], kind: KeyedFloatKind): KeyedFloatValidation;
 

package/dist/reference/keyed-float-validate.js

@@ -32,7 +32,7 @@ function validateKeyedFloats(lessons, kind) {
     const table = {};
     for (const raw of scanKeyedJsxFloats(lesson.body, {
       tagName,
-      chapter: lesson.chapter
+      numbering: lesson.numbering
     })) {
       if (raw.key == null) continue;
       if (!KEYED_FLOAT_KEY_PATTERN.test(raw.key)) {

package/dist/reference/keyed-jsx-floats.d.mts

@@ -20,31 +20,39 @@ export function parseKeyedFloatRef(raw: any, { prefix }: {
 /**
  * The raw-text equivalent of `collectKeyedJsxFloats`, mirroring
  * `scanEquationLabels`: every top-level `<TagName …>` in appearance order.
- * With `chapter` (the lesson's course ordinal) the number is `‹chapter›.‹n›`,
- * `n` sequential over the whole lesson; without it, `##` headings advance a
- * section counter. Other JSX components' bodies are blanked first so a
- * `<Table>` nested inside e.g. `<CompactExample>` (and any `##`-like text
- * inside an unrelated component) is never counted.
+ * With `numbering` (`{ prefix, offset }` — the part's ordinal and the count of
+ * this kind of float in earlier lessons of that part) the number is
+ * `‹part›.‹offset + n›`, `n` sequential over the whole lesson; without it, `##`
+ * headings advance a section counter. Other JSX components' bodies are blanked
+ * first so a `<Table>` nested inside e.g. `<CompactExample>` (and any `##`-like
+ * text inside an unrelated component) is never counted.
  */
-export function scanKeyedJsxFloats(markdown: any, { tagName, chapter }: {
+export function scanKeyedJsxFloats(markdown: any, { tagName, numbering }: {
     tagName: any;
-    chapter: any;
+    numbering: any;
 }): {
     key: string | null | undefined;
     number: string;
     section: number;
     indexInSection: number;
 }[];
+/**
+ * How many floats of this kind a lesson body holds — the input to the next
+ * lesson's `offset` within the same part.
+ */
+export function countKeyedJsxFloats(markdown: any, { tagName }: {
+    tagName: any;
+}): number;
 /**
  * The mdast equivalent of `scanKeyedJsxFloats`: walk the tree's *top-level*
  * children in document order, advancing the section counter on every
  * depth-2 heading and emitting a record for every `mdxJsxFlowElement` named
- * `tagName` — keyed or not, exactly like `collectDisplayEquations`. `chapter`
+ * `tagName` — keyed or not, exactly like `collectDisplayEquations`. `numbering`
  * is threaded the same way as in `scanKeyedJsxFloats`.
  */
-export function collectKeyedJsxFloats(tree: any, { tagName, chapter }: {
+export function collectKeyedJsxFloats(tree: any, { tagName, numbering }: {
     tagName: any;
-    chapter: any;
+    numbering: any;
 }): {
     key: any;
     number: string;

package/dist/reference/keyed-jsx-floats.mjs

@@ -22,7 +22,11 @@
  * `equations.test.ts` holds equations to.
  */
 
-import { stripFencedCode, stripJsxComponents } from './equations.mjs';
+import {
+  resolveNumbering,
+  stripFencedCode,
+  stripJsxComponents,
+} from './equations.mjs';
 
 /** Same shape as `EQ_KEY_PATTERN` — the notation-key grammar without dots. */
 export const KEYED_FLOAT_KEY_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -33,15 +37,22 @@ function floatNumber(section, index) {
 }
 
 /**
- * The visible number for one float. With `chapter` (the lesson's course
- * ordinal) the scheme is `‹chapter›.‹indexInLesson›` and `##` headings are
- * ignored; without it, the legacy `##`-section scheme. Mirrors
- * `displayEquationNumber` in `equations.mjs`.
+ * The visible number for one float. With a `prefix` (the part's ordinal) the
+ * scheme is `‹part›.‹offset + indexInLesson›` and `##` headings are ignored;
+ * without it, the legacy `##`-section scheme. Mirrors `displayEquationNumber`
+ * in `equations.mjs`. Each kind of float counts on its own — a `<Table>` never
+ * advances the `<Figure>` sequence — so `offset` is per kind too.
  */
-function keyedFloatNumber({ chapter, section, indexInSection, indexInLesson }) {
-  return chapter == null
+function keyedFloatNumber({
+  prefix,
+  offset = 0,
+  section,
+  indexInSection,
+  indexInLesson,
+}) {
+  return prefix == null
     ? floatNumber(section, indexInSection)
-    : `${chapter}.${indexInLesson}`;
+    : `${prefix}.${offset + indexInLesson}`;
 }
 
 /** The anchor id for a float, e.g. `{prefix:'tab', key:'foo'}` → `tab-foo`. */
@@ -71,13 +82,15 @@ function readIdAttribute(attributesSource) {
 /**
  * The raw-text equivalent of `collectKeyedJsxFloats`, mirroring
  * `scanEquationLabels`: every top-level `<TagName …>` in appearance order.
- * With `chapter` (the lesson's course ordinal) the number is `‹chapter›.‹n›`,
- * `n` sequential over the whole lesson; without it, `##` headings advance a
- * section counter. Other JSX components' bodies are blanked first so a
- * `<Table>` nested inside e.g. `<CompactExample>` (and any `##`-like text
- * inside an unrelated component) is never counted.
+ * With `numbering` (`{ prefix, offset }` — the part's ordinal and the count of
+ * this kind of float in earlier lessons of that part) the number is
+ * `‹part›.‹offset + n›`, `n` sequential over the whole lesson; without it, `##`
+ * headings advance a section counter. Other JSX components' bodies are blanked
+ * first so a `<Table>` nested inside e.g. `<CompactExample>` (and any `##`-like
+ * text inside an unrelated component) is never counted.
  */
-export function scanKeyedJsxFloats(markdown, { tagName, chapter }) {
+export function scanKeyedJsxFloats(markdown, { tagName, numbering }) {
+  const { prefix, offset } = resolveNumbering(numbering);
   const text = stripJsxComponents(stripFencedCode(markdown), tagName);
   const tokens = [];
   const heading = /^[ \t]{0,3}##[ \t]+\S/gm;
@@ -106,7 +119,8 @@ export function scanKeyedJsxFloats(markdown, { tagName, chapter }) {
     labels.push({
       key: token.key,
       number: keyedFloatNumber({
-        chapter,
+        prefix,
+        offset,
         section,
         indexInSection,
         indexInLesson,
@@ -118,14 +132,23 @@ export function scanKeyedJsxFloats(markdown, { tagName, chapter }) {
   return labels;
 }
 
+/**
+ * How many floats of this kind a lesson body holds — the input to the next
+ * lesson's `offset` within the same part.
+ */
+export function countKeyedJsxFloats(markdown, { tagName }) {
+  return scanKeyedJsxFloats(markdown, { tagName }).length;
+}
+
 /**
  * The mdast equivalent of `scanKeyedJsxFloats`: walk the tree's *top-level*
  * children in document order, advancing the section counter on every
  * depth-2 heading and emitting a record for every `mdxJsxFlowElement` named
- * `tagName` — keyed or not, exactly like `collectDisplayEquations`. `chapter`
+ * `tagName` — keyed or not, exactly like `collectDisplayEquations`. `numbering`
  * is threaded the same way as in `scanKeyedJsxFloats`.
  */
-export function collectKeyedJsxFloats(tree, { tagName, chapter }) {
+export function collectKeyedJsxFloats(tree, { tagName, numbering }) {
+  const { prefix, offset } = resolveNumbering(numbering);
   const floats = [];
   let section = 0;
   let indexInSection = 0;
@@ -151,7 +174,8 @@ export function collectKeyedJsxFloats(tree, { tagName, chapter }) {
       floats.push({
         key: key ?? null,
         number: keyedFloatNumber({
-          chapter,
+          prefix,
+          offset,
           section,
           indexInSection,
           indexInLesson,

package/dist/reference/remark-notation.d.mts

@@ -1,29 +1,78 @@
+/**
+ * The numbering inputs a lesson page needs, read off one manifest.
+ *
+ * Every number on a page comes from two places that MUST agree: the page's own
+ * counters (`numbering`) and the manifest tables a cross-page `[[slug#eq-key]]`
+ * is resolved against (`equations` / `tables` / `figures`). Deriving all four
+ * from the same manifest in one step is what stops a course config from
+ * supplying one without the other — the omission that produced page-local
+ * `(2.2)` and cross-page `(4.5)` for the same equation.
+ *
+ * `numbering` maps a lesson slug to `{ part, equations, tables, figures }`:
+ * the part's ordinal (the number before the dot) and, per kind of float, how
+ * many of them the earlier lessons of that part already used.
+ */
+export function numberingFromManifest(manifest: any): {
+    equations?: undefined;
+    tables?: undefined;
+    figures?: undefined;
+    numbering?: undefined;
+} | {
+    equations: any;
+    tables: any;
+    figures: any;
+    numbering: {
+        [k: string]: any;
+    };
+};
 /**
  * @param {{
  *   definitions?: Map<string, object> | readonly object[] | Record<string, object> | (() => Map<string, object> | readonly object[] | Record<string, object>),
  *   resolve?: (key: string, context: object) => object | undefined,
  *   unknown?: 'error' | 'warn' | 'ignore',
  *   base?: string,
+ *   manifest?: object,
  *   equations?: Record<string, Record<string, string>>,
  *   tables?: Record<string, Record<string, string>>,
  *   figures?: Record<string, Record<string, string>>,
+ *   numbering?: Record<string, { part: number, equations: number, tables: number, figures: number }>,
  *   chapters?: Record<string, number>,
  * }} [options]
  *
- * `chapters` maps a lesson slug to its 1-based course ordinal. When the
- * current page has one, every display equation / `<Table>` / `<Figure>` is
- * numbered `‹chapter›.‹n›` (`##` headings ignored); with no entry the legacy
- * `##`-section scheme applies. It must agree with `manifest.lessons[].chapter`,
- * which is what feeds `equations`/`tables`/`figures` above.
+ * `manifest` is the preferred wiring: pass the compiled manifest and the four
+ * numbering inputs below are read off it together, so they cannot drift apart.
+ * They stay available individually for hand-built trees, and an explicitly
+ * supplied one still wins over the manifest.
+ *
+ * `numbering` maps a lesson slug to its **part** (the number before the dot)
+ * and, per kind of float, how many the earlier lessons of that part already
+ * used. Every display equation / `<Table>` / `<Figure>` on the page is then
+ * numbered `‹part›.‹offset + n›`, with `##` and `###` headings ignored; with no
+ * entry the legacy `##`-section scheme applies. It must agree with
+ * `manifest.lessons[]`, which is what feeds `equations`/`tables`/`figures`
+ * above — supplying the tables without `numbering` numbers the same equation
+ * twice, and `assertManifestNumberParity` turns that into a build error rather
+ * than a page whose references disagree with their targets.
+ *
+ * `chapters` is the superseded per-lesson form (slug → the lesson's course
+ * ordinal, no running offset). Still read when `numbering` has no entry, so a
+ * config written against the old option keeps building.
  */
 export default function remarkNotation(options?: {
     definitions?: Map<string, object> | readonly object[] | Record<string, object> | (() => Map<string, object> | readonly object[] | Record<string, object>);
     resolve?: (key: string, context: object) => object | undefined;
     unknown?: "error" | "warn" | "ignore";
     base?: string;
+    manifest?: object;
     equations?: Record<string, Record<string, string>>;
     tables?: Record<string, Record<string, string>>;
     figures?: Record<string, Record<string, string>>;
+    numbering?: Record<string, {
+        part: number;
+        equations: number;
+        tables: number;
+        figures: number;
+    }>;
     chapters?: Record<string, number>;
 }): (tree: any, file: any) => void;
 /**