explico 0.2.0 → 0.4.0

package/src/reference/math-glyphs.mjs

@@ -828,3 +828,95 @@ export function resolveMathGlyphs(latex, definitions) {
     unresolved: unresolvedIdentifiers(latex, identifiers, bindings),
   };
 }
+
+// --- named operators ------------------------------------------------
+
+/**
+ * Every named operator in one KaTeX expression: a built-in `op` node
+ * (`\exp`, `\int`, `\sum`, …) or an author-declared `\operatorname{…}` /
+ * `\mathop{…}` (`Var`, `Cov`, …). The `name` is the KaTeX command without its
+ * backslash for a built-in, and the verbatim body for a declared one — the
+ * form `BASE_OPERATORS` and `course.config.ts` `operators` are keyed by.
+ *
+ * Pure read: unlike `resolveMathGlyphs`, nothing here rewrites the source.
+ * Used by the `operator-explained` consistency check (rule N8); the glyph
+ * resolver still skips operator bodies whole.
+ *
+ * @param {string} latex
+ * @returns {Array<{ name: string, source: 'named' | 'operatorname' }>}
+ */
+export function collectOperators(latex) {
+  if (typeof latex !== 'string' || latex.trim() === '') return [];
+
+  let tree;
+  try {
+    tree = parseMath(latex, 'operator scan');
+  } catch (error) {
+    // A span that will not parse is the math gate's problem, not this check's.
+    // A KaTeX version-pin failure is nobody's to swallow — let it through.
+    if (error instanceof GlyphResolutionError && error.code === 'invalid-latex') {
+      return [];
+    }
+    throw error;
+  }
+
+  const seen = new Set();
+  const operators = [];
+  const add = (name, source) => {
+    const trimmed = typeof name === 'string' ? name.trim() : '';
+    if (trimmed === '') return;
+    const identity = `${source}:${trimmed}`;
+    if (seen.has(identity)) return;
+    seen.add(identity);
+    operators.push({ name: trimmed, source });
+  };
+
+  // The declared-operator name is its letters with any internal spacing
+  // dropped, so `\operatorname{arg\,max}` keys as `argmax` — `fontBodyText`
+  // alone bails on the `\,`.
+  const declaredName = (body) => {
+    const direct = fontBodyText(body);
+    if (typeof direct === 'string') return direct;
+    const letters = [];
+    const gather = (value) => {
+      if (Array.isArray(value)) {
+        value.forEach(gather);
+        return;
+      }
+      if (!isNode(value)) return;
+      if (value.type === 'mathord' || value.type === 'textord') {
+        letters.push(value.text ?? '');
+      }
+      if (value.type === 'ordgroup') gather(value.body);
+    };
+    gather(body);
+    return letters.join('');
+  };
+
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const child of value) visit(child);
+      return;
+    }
+    if (!isNode(value)) return;
+
+    if (value.type === 'operatorname') {
+      add(declaredName(value.body), 'operatorname');
+    } else if (value.type === 'op') {
+      if (typeof value.name === 'string' && value.name.length > 0) {
+        add(value.name.replace(/^\\/, ''), 'named');
+      } else if (value.body !== undefined) {
+        // `\mathop{Foo}` — a hand-rolled operator with no command name.
+        add(declaredName(value.body), 'operatorname');
+      }
+    }
+
+    for (const key of Object.keys(value)) {
+      if (key === 'loc') continue;
+      visit(value[key]);
+    }
+  };
+
+  visit(tree);
+  return operators;
+}

package/src/reference/remark-notation.mjs

@@ -42,6 +42,11 @@ import {
   parseEquationRef,
   stripEquationLabels,
 } from './equations.mjs';
+import {
+  collectKeyedJsxFloats,
+  keyedFloatAnchorId,
+  parseKeyedFloatRef,
+} from './keyed-jsx-floats.mjs';
 
 const PROSE_SKIP_TYPES = new Set([
   'code',
@@ -340,6 +345,8 @@ function equationNode(mathNode, { key, number }) {
             className: ['keyed-equation__number'],
             'data-eq-number': number,
             'aria-label': `Equation ${number}`,
+            // Plain hover tooltip — the number is a permalink to this equation.
+            title: 'Anchor to this equation',
           },
         },
       },
@@ -347,6 +354,32 @@ function equationNode(mathNode, { key, number }) {
   };
 }
 
+/**
+ * Give a `<Table>`/`<Figure>` `mdxJsxFlowElement` its computed `number` and
+ * `anchorId` as real JSX attributes, so the actual Astro component (which
+ * renders the numbered anchor, unlike `equationNode`'s synthesized hast div)
+ * receives them as props. The compiler is the single source of truth for
+ * both — the component only renders what it's given.
+ */
+function injectFloatNumberAttributes(node, float, prefix) {
+  const anchorId = keyedFloatAnchorId({
+    key: float.key,
+    number: float.number,
+    prefix,
+  });
+  node.attributes = (node.attributes ?? []).filter(
+    (attribute) =>
+      !(
+        attribute?.type === 'mdxJsxAttribute' &&
+        (attribute.name === 'number' || attribute.name === 'anchorId')
+      ),
+  );
+  node.attributes.push(
+    { type: 'mdxJsxAttribute', name: 'number', value: float.number },
+    { type: 'mdxJsxAttribute', name: 'anchorId', value: anchorId },
+  );
+}
+
 /** Resolve a `[[eq-key]]` / `[[slug#eq-key]]` reference to `{ number, href }`. */
 function resolveEquationRef(eqRef, eqCtx, file, node) {
   if (eqRef.lesson) {
@@ -374,7 +407,47 @@ function resolveEquationRef(eqRef, eqCtx, file, node) {
   return { number, href: `#eq-${eqRef.key}` };
 }
 
-function proseNodes(value, resolve, file, node, references, eqCtx) {
+/**
+ * Resolve a `[[<prefix>-key]]` / `[[slug#<prefix>-key]]` reference (a
+ * `<Table>`/`<Figure>` float) to `{ number, href }` — the table/figure
+ * equivalent of `resolveEquationRef`.
+ */
+function resolveKeyedFloatRef(floatRef, ctx, { prefix, tagName }, file, node) {
+  if (floatRef.lesson) {
+    const number = ctx.crossPage?.[floatRef.lesson]?.[floatRef.key];
+    if (number === undefined) {
+      fail(
+        file,
+        `Unknown ${tagName} reference [[${floatRef.lesson}#${prefix}-${floatRef.key}]]: lesson ${floatRef.lesson} has no <${tagName}> with id="${floatRef.key}".`,
+        node,
+      );
+    }
+    return {
+      number,
+      href: `${ctx.base.replace(/\/$/, '')}/${floatRef.lesson}/#${prefix}-${floatRef.key}`,
+    };
+  }
+  const number = ctx.pageLabels.get(floatRef.key);
+  if (number === undefined) {
+    fail(
+      file,
+      `Unknown ${tagName} reference [[${prefix}-${floatRef.key}]]: no <${tagName}> on this page carries id="${floatRef.key}".`,
+      node,
+    );
+  }
+  return { number, href: `#${prefix}-${floatRef.key}` };
+}
+
+function proseNodes(
+  value,
+  resolve,
+  file,
+  node,
+  references,
+  eqCtx,
+  tableCtx,
+  figureCtx,
+) {
   const base = eqCtx?.base ?? '';
   const strayExplain = firstUnescaped(value, EXPLAIN);
   if (strayExplain !== -1) {
@@ -395,7 +468,18 @@ function proseNodes(value, resolve, file, node, references, eqCtx) {
 
     const key = match[1].trim();
     const eqRef = eqCtx ? parseEquationRef(key) : undefined;
-    if (!eqRef && !NOTATION_KEY_PATTERN.test(key)) {
+    const tableRef =
+      !eqRef && tableCtx ? parseKeyedFloatRef(key, { prefix: 'tab' }) : undefined;
+    const figureRef =
+      !eqRef && !tableRef && figureCtx
+        ? parseKeyedFloatRef(key, { prefix: 'fig' })
+        : undefined;
+    if (
+      !eqRef &&
+      !tableRef &&
+      !figureRef &&
+      !NOTATION_KEY_PATTERN.test(key)
+    ) {
       fail(file, `Invalid notation key "${key}" in [[...]].`, node);
     }
 
@@ -426,9 +510,46 @@ function proseNodes(value, resolve, file, node, references, eqCtx) {
       continue;
     }
 
+    const floatRef = tableRef ?? figureRef;
+    if (floatRef) {
+      const kind = tableRef ? 'table' : 'figure';
+      const prefix = tableRef ? 'tab' : 'fig';
+      const tagName = tableRef ? 'Table' : 'Figure';
+      const { number, href } = resolveKeyedFloatRef(
+        floatRef,
+        tableRef ? tableCtx : figureCtx,
+        { prefix, tagName },
+        file,
+        node,
+      );
+      output.push({
+        type: 'link',
+        url: href,
+        children: [{ type: 'text', value: `${tagName} ${number}` }],
+        data: {
+          hProperties: {
+            className: [`${kind}-ref`],
+            [`data-${prefix}-ref`]: floatRef.key,
+            ...(floatRef.lesson ? { [`data-${prefix}-lesson`]: floatRef.lesson } : {}),
+          },
+        },
+      });
+      references.push({
+        key: floatRef.key,
+        kind,
+        ...(floatRef.lesson ? { lesson: floatRef.lesson } : {}),
+      });
+      cursor = match.index + match[0].length;
+      continue;
+    }
+
     const definition = resolve(key, 'prose', node);
-    const title = definition?.title ?? key;
-    const summary = definition?.summary;
+    // `title`/`summary` are the pre-C1b field names, kept as the first
+    // fallback for a caller still supplying them; real content authors
+    // `label`/`meaning` (see `content-config.ts`), which raw frontmatter
+    // (`manifest.notation.raw`, a page's own `notation.local`) carries as-is.
+    const title = definition?.title ?? definition?.label ?? key;
+    const summary = definition?.summary ?? definition?.meaning;
     const href = defaultHref(definition, key, base);
 
     const properties = {
@@ -550,17 +671,146 @@ function inspectExplainCalls(value, resolve, file, node, references) {
   }
 }
 
+/**
+ * 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) {
+  if (!manifest || typeof manifest !== 'object') return {};
+  return {
+    equations: manifest.equations?.numbersBySlug ?? {},
+    tables: manifest.tables?.numbersBySlug ?? {},
+    figures: manifest.figures?.numbersBySlug ?? {},
+    numbering: Object.fromEntries(
+      (manifest.lessons ?? []).map((lesson) => [
+        lesson.slug,
+        {
+          part: lesson.part,
+          equations: lesson.numbering?.equations ?? 0,
+          tables: lesson.numbering?.tables ?? 0,
+          figures: lesson.numbering?.figures ?? 0,
+        },
+      ]),
+    ),
+  };
+}
+
+/**
+ * `{ prefix, offset }` for one kind of float on one page, from whichever
+ * numbering option the caller supplied. `numbering` is the current form;
+ * `chapters` is the superseded per-lesson form (prefix = the lesson's ordinal,
+ * no offset) and is still read so an unmigrated config keeps working.
+ */
+function pageNumbering(options, slug, kind) {
+  if (!slug) return undefined;
+  const placement = options.numbering?.[slug];
+  if (placement?.part) {
+    return { prefix: placement.part, offset: placement[kind] ?? 0 };
+  }
+  const chapter = options.chapters?.[slug];
+  return chapter ? { prefix: chapter, offset: 0 } : undefined;
+}
+
+/**
+ * Fail when the number this page just computed for a keyed float disagrees
+ * with the number the manifest publishes for the same key (WERN — a reference
+ * that shows a different number than its target). The two are produced by the
+ * same algorithm from the same content, so any disagreement means the render
+ * path and the manifest were fed different inputs; in practice, an
+ * `astro.config.mjs` that passes the manifest number tables but not
+ * `numbering`, which silently drops the page back to the legacy `##`-section
+ * scheme.
+ */
+function assertManifestNumberParity({
+  file,
+  slug,
+  pageLabels,
+  crossPage,
+  placement,
+  noun,
+  syntax,
+}) {
+  // No entry for this slug at all means the caller supplied no manifest table
+  // (hand-built test trees, non-lesson pages) — nothing to cross-check.
+  const published = crossPage?.[slug];
+  if (!published) return;
+
+  for (const [key, number] of pageLabels) {
+    const expected = published[key];
+    if (expected === undefined) {
+      fail(
+        file,
+        `Stale Explico manifest for ${slug}: this page numbers ${noun} ` +
+          `${syntax(key)} as (${number}), but the manifest lists no such ` +
+          `${noun} for the lesson. Recompile the manifest before rendering.`,
+      );
+    }
+    if (expected !== number) {
+      fail(
+        file,
+        `Inconsistent ${noun} numbering for ${syntax(key)} in ${slug}: this ` +
+          `page renders it as (${number}) while a cross-page reference to it ` +
+          `resolves to (${expected}). ` +
+          (placement === undefined
+            ? 'The remarkNotation options carry the manifest number tables ' +
+              'but no `numbering` entry for this lesson, so the page fell ' +
+              'back to the legacy `##`-section scheme. Pass `manifest` to ' +
+              'remarkNotation so both sides use the part scheme.'
+            : 'The page counters and the manifest disagree; recompile the ' +
+              'manifest from the current content.'),
+      );
+    }
+  }
+}
+
 /**
  * @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]
+ *
+ * `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 = {}) {
   const unknown = options.unknown ?? 'error';
+  // The manifest supplies every numbering input at once; an explicit option
+  // still overrides it, so existing per-field wiring keeps working.
+  const numbering = { ...numberingFromManifest(options.manifest), ...options };
 
   return function transform(tree, file) {
     const suppliedDefinitions =
@@ -573,6 +823,10 @@ export default function remarkNotation(options = {}) {
     );
     const localDefinitions = localDefinitionsFromFile(file);
     const lessonId = lessonIdFrom(file);
+    const lessonSlug = lessonId ? lessonId.replace(/\./g, '/') : undefined;
+    // `{ prefix, offset }` per kind of float — see the `numbering` option.
+    // Missing ⇒ the legacy `##`-section numbering.
+    const equationNumbering = pageNumbering(numbering, lessonSlug, 'equations');
     const registryFile = isNotationRegistryFile(file);
     const mathScope = pageGlyphScope(
       localDefinitions,
@@ -582,10 +836,11 @@ export default function remarkNotation(options = {}) {
     const references = [];
     const resolved = new Map();
 
-    // Equation identity (D7): assign every `\label{eq:…}` its section-scoped
-    // number before any math node is rewritten, so a `[[eq-key]]` earlier in
-    // the page still resolves.
-    const equationLabels = collectEquationLabels(tree);
+    // Equation identity (D7): assign every `\label{eq:…}` its number before any
+    // math node is rewritten, so a `[[eq-key]]` earlier in the page still
+    // resolves. `equationNumbering` picks the `‹part›.‹n›` vs `##`-section
+    // scheme.
+    const equationLabels = collectEquationLabels(tree, equationNumbering);
     const pageLabels = new Map();
     for (const label of equationLabels) {
       if (pageLabels.has(label.key)) {
@@ -600,17 +855,79 @@ export default function remarkNotation(options = {}) {
     const eqCtx = {
       base: options.base ?? '',
       pageLabels,
-      crossPage: options.equations ?? {},
+      crossPage: numbering.equations ?? {},
     };
+    // WERN guard: what this page prints next to the equation must be what a
+    // reference from another page prints for it.
+    assertManifestNumberParity({
+      file,
+      slug: lessonSlug,
+      pageLabels,
+      crossPage: eqCtx.crossPage,
+      placement: equationNumbering,
+      noun: 'equation',
+      syntax: (key) => `eq:${key}`,
+    });
 
     // Number and anchor every display equation on a lesson page, keyed or
     // not (F3). Non-lesson pages (notation registry, stray docs) keep the
     // keyed-only behaviour so their body math is left untouched.
-    const displayEquations = lessonId ? collectDisplayEquations(tree) : [];
+    const displayEquations = lessonId
+      ? collectDisplayEquations(tree, equationNumbering)
+      : [];
     const equationByNode = new Map(
       displayEquations.map((equation) => [equation.node, equation]),
     );
 
+    // Keyed floats (F-tables-figures): every `<Table>`/`<Figure>` on a lesson
+    // page is numbered and anchored, keyed or not — same rule as equations,
+    // via the shared engine in `keyed-jsx-floats.mjs`.
+    const makeFloatCtx = (tagName, crossPage, kind) => {
+      const floatNumbering = pageNumbering(numbering, lessonSlug, kind);
+      const floats = lessonId
+        ? collectKeyedJsxFloats(tree, { tagName, numbering: floatNumbering })
+        : [];
+      const pageFloatLabels = new Map();
+      for (const float of floats) {
+        if (float.key == null) continue;
+        if (pageFloatLabels.has(float.key)) {
+          fail(
+            file,
+            `Duplicate <${tagName} id="${float.key}"> on this page; an id is unique per lesson.`,
+            float.node,
+          );
+        }
+        pageFloatLabels.set(float.key, float.number);
+      }
+      assertManifestNumberParity({
+        file,
+        slug: lessonSlug,
+        pageLabels: pageFloatLabels,
+        crossPage: crossPage ?? {},
+        placement: floatNumbering,
+        noun: tagName,
+        syntax: (key) => `<${tagName} id="${key}">`,
+      });
+      return {
+        ctx: {
+          base: options.base ?? '',
+          pageLabels: pageFloatLabels,
+          crossPage: crossPage ?? {},
+        },
+        byNode: new Map(floats.map((float) => [float.node, float])),
+      };
+    };
+    const { ctx: tableCtx, byNode: tableByNode } = makeFloatCtx(
+      'Table',
+      numbering.tables,
+      'tables',
+    );
+    const { ctx: figureCtx, byNode: figureByNode } = makeFloatCtx(
+      'Figure',
+      numbering.figures,
+      'figures',
+    );
+
     const resolve = (key, kind, node) => {
       const context = {
         file,
@@ -729,6 +1046,8 @@ export default function remarkNotation(options = {}) {
             child,
             references,
             eqCtx,
+            tableCtx,
+            figureCtx,
           );
           if (replacement) {
             node.children.splice(index, 1, ...replacement);
@@ -739,6 +1058,10 @@ export default function remarkNotation(options = {}) {
         visit(child, false);
         if (child && child.type === 'math' && equationByNode.has(child)) {
           node.children[index] = equationNode(child, equationByNode.get(child));
+        } else if (child?.type === 'mdxJsxFlowElement' && tableByNode.has(child)) {
+          injectFloatNumberAttributes(child, tableByNode.get(child), 'tab');
+        } else if (child?.type === 'mdxJsxFlowElement' && figureByNode.has(child)) {
+          injectFloatNumberAttributes(child, figureByNode.get(child), 'fig');
         }
       }
     };
@@ -755,5 +1078,16 @@ export default function remarkNotation(options = {}) {
         indexInSection,
       }),
     );
+    const floatLabelData = (byNode) =>
+      [...byNode.values()]
+        .filter((float) => float.key != null)
+        .map(({ key, number, section, indexInSection }) => ({
+          key,
+          number,
+          section,
+          indexInSection,
+        }));
+    file.data.tableLabels = floatLabelData(tableByNode);
+    file.data.figureLabels = floatLabelData(figureByNode);
   };
 }

package/src/reference/tables-validate.ts

@@ -0,0 +1,40 @@
+/** `validateKeyedFloats` for `<Table>` — see `keyed-float-validate.ts`. */
+
+import {
+  validateKeyedFloats,
+  type KeyedFloatLabelRecord,
+  type KeyedFloatLessonInput,
+  type KeyedFloatValidation,
+} from './keyed-float-validate';
+
+export type TableDiagnosticCode =
+  | 'tab-invalid-key'
+  | 'tab-duplicate-key'
+  | 'tab-ref-resolves'
+  | 'tab-key-unused';
+
+export interface TableDiagnostic {
+  readonly code: TableDiagnosticCode;
+  readonly severity: 'error' | 'warning';
+  readonly message: string;
+  readonly file?: string;
+  readonly lessonId?: string;
+  readonly key?: string;
+}
+
+export type TableLabelRecord = KeyedFloatLabelRecord;
+export type TableLessonInput = KeyedFloatLessonInput;
+
+export interface TableValidation extends KeyedFloatValidation {
+  readonly diagnostics: readonly TableDiagnostic[];
+}
+
+export function validateTables(
+  lessons: readonly TableLessonInput[],
+): TableValidation {
+  return validateKeyedFloats(lessons, {
+    tagName: 'Table',
+    prefix: 'tab',
+    noun: 'table',
+  }) as TableValidation;
+}

package/src/reference/units-vocab.ts

@@ -118,6 +118,24 @@ export const UNITS_VOCAB: ReadonlySet<string> = new Set([
   'quoted',
   'explicitly',
   'calculations',
+  // motion / physical quantities (playground corpus)
+  'meter',
+  'meters',
+  'second',
+  'seconds',
+  'speed',
+  'velocity',
+  'acceleration',
+  'gravitational',
+  'launch',
+  'angle',
+  'degrees',
+  'horizontal',
+  'vertical',
+  'level',
+  'ground',
+  'squared',
+  'above',
 ]);
 
 /** Lowercase word tokens of a `units` string (split on whitespace and hyphens). */