explico 0.2.0 → 0.4.0

package/dist/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/dist/reference/tables-validate.d.ts

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

package/dist/reference/tables-validate.js

@@ -0,0 +1,13 @@
+import {
+  validateKeyedFloats
+} from "./keyed-float-validate.js";
+function validateTables(lessons) {
+  return validateKeyedFloats(lessons, {
+    tagName: "Table",
+    prefix: "tab",
+    noun: "table"
+  });
+}
+export {
+  validateTables
+};

package/dist/reference/units-vocab.js

@@ -97,7 +97,25 @@ const UNITS_VOCAB = /* @__PURE__ */ new Set([
   "quantity",
   "quoted",
   "explicitly",
-  "calculations"
+  "calculations",
+  // motion / physical quantities (playground corpus)
+  "meter",
+  "meters",
+  "second",
+  "seconds",
+  "speed",
+  "velocity",
+  "acceleration",
+  "gravitational",
+  "launch",
+  "angle",
+  "degrees",
+  "horizontal",
+  "vertical",
+  "level",
+  "ground",
+  "squared",
+  "above"
 ]);
 function unitsTokens(units) {
   return units.toLowerCase().split(/[\s]+/).flatMap((word) => word.split(/(?<=[a-z0-9])-(?=[a-z])/)).map((word) => word.replace(/^[^a-z0-9_]+|[^a-z0-9_]+$/g, "")).filter((word) => word.length > 0 && !/^\d+$/.test(word));

package/docs/VERSIONING.md

@@ -0,0 +1,66 @@
+# Versioning
+
+`explico` follows [Semantic Versioning](https://semver.org/). The installed
+`package.json` `version` is authoritative for what a consumer has;
+[`CHANGELOG.md`](../CHANGELOG.md) records what changed; this file defines what a
+bump *means*.
+
+There are two independent version streams. This document is about the **engine**.
+A course built on explico carries its own **knowledge version** over its
+content — see [`authoring/versioning.md`](authoring/versioning.md).
+
+## The public surface
+
+A change is "breaking" when it can break a consumer who followed the docs. The
+consumer-visible surface is:
+
+| Surface | Where |
+| --- | --- |
+| Published module entry points | `package.json` `publishConfig.exports` — the `explico/*` specifiers and their `.d.ts` |
+| Astro / React components | names + props of everything under `components/` that the README wires |
+| remark / rehype adapter options | the option objects of `reference/*.mjs` (`remarkNotation`, `remarkCitation`, `createNotationKatexOptions`, …) |
+| The compiler manifest | `MANIFEST_SCHEMA_VERSION` and the shape of `Manifest` |
+| The `content` CLI | the commands, their flags, and every diagnostic `code` string |
+| `CourseConfig` | the interface in `compiler/course-config.ts` |
+| Build-enforced authoring rules | the `N*` / `V*` / `C*` rules marked *Build-enforced* in `docs/authoring/` |
+
+## What each bump means
+
+**MAJOR** — an incompatible change to any surface above: removing or renaming an
+export, a component, a prop, or a CLI command; adding a required `CourseConfig`
+field; a breaking change to the manifest shape (which also bumps
+`MANIFEST_SCHEMA_VERSION`); tightening a build-enforced rule so content that
+passed now fails.
+
+**MINOR** — a backward-compatible addition: a new export, component, or optional
+`CourseConfig` field; a new opt-in authoring rule; a new manifest field
+(additive — still bump `MANIFEST_SCHEMA_VERSION`, note it additive in
+`CHANGELOG.md`).
+
+**PATCH** — a bug fix, a docs change, an internal refactor with no surface
+change, or a new **Tier-3 warning** (warnings never fail a build, so surfacing
+one does not break a consumer).
+
+### Pre-1.0
+
+While the version is `0.x`, a **MINOR** bump *may* include a breaking change —
+every one is listed under a `### Breaking` heading in `CHANGELOG.md` for that
+version. A **PATCH** never breaks. Once the API settles this clause is dropped
+and normal semver applies.
+
+## Cutting a release
+
+1. Decide the next version from the rules above and the `## [Unreleased]`
+   section of `CHANGELOG.md`.
+2. `CHANGELOG.md`: rename `## [Unreleased]` to `## [x.y.z] - YYYY-MM-DD`, add a
+   fresh empty `## [Unreleased]`, and fix up the compare links at the bottom.
+3. Bump `package.json` `version` (`npm version x.y.z --no-git-tag-version`).
+4. `pnpm build && pnpm test`.
+5. Commit, then `git tag vx.y.z`.
+
+## When you change the engine
+
+Every PR that touches the public surface adds a bullet under `## [Unreleased]`
+in `CHANGELOG.md`, in the right group (`Added` / `Changed` / `Fixed` /
+`Removed`, plus `Breaking` when it is). Pick the group by the rules above; the
+version number itself is set only at release time. See [`AGENTS.md`](../AGENTS.md).