explico 0.1.0 → 0.2.0

package/dist/reference/equations.mjs

@@ -1,22 +1,24 @@
 /**
- * Equation identity (Step D7) — shared, framework-free helpers.
+ * Equation identity (Step D7, extended F3) — shared, framework-free helpers.
  *
- * An author marks a display equation by putting a trailing `\label{eq:<key>}`
- * inside its `$$…$$` block (inside math, so the `:` is safe and the form
- * matches amsmath). The compiler assigns the *visible* number from appearance
- * order, scoped to the enclosing `##` section (`(2.4)` = fourth keyed equation
- * under the second section). The number is never authored; unkeyed display
- * equations render clean and stay un-referenceable. Prose refers to an
- * equation with the reserved `eq-` prefix (a bare `:` in `[[…]]` prose would
- * be eaten by `remark-directive`):
+ * Every display equation (`$$…$$`) in a lesson is numbered and given an
+ * `id`, from appearance order scoped to the enclosing `##` section (`(2.4)` =
+ * fourth display equation under the second section). 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:
  *
  *   [[eq-discount-factor-def]]           same page  → "(2.4)" linked to #eq-…
  *   [[foundations/present-value#eq-pv]]  cross page → number from the manifest
  *
+ * An unkeyed equation still gets a positional anchor (`#eq-2-4`) so it can be
+ * deep-linked, but only a keyed equation is referenceable by name.
+ *
  * `scanEquationLabels` (raw Markdown) and `collectEquationLabels` (mdast tree)
  * MUST agree — `tests/notation/equations.test.ts` checks that on the real
  * corpus. Both are here so `manifest.ts` and `remark-notation.mjs` share one
- * numbering algorithm.
+ * numbering algorithm. `collectDisplayEquations` is the superset the render
+ * path uses to number and anchor every display equation, keyed or not.
  */
 
 /** `eq:` key grammar — the notation-key shape without the dotted namespaces. */
@@ -51,11 +53,16 @@ export function stripEquationLabels(latex) {
     .trim();
 }
 
-/** The visible number for the `index`-th keyed equation under `section`. */
+/** The visible number for the `index`-th display equation under `section`. */
 function equationNumber(section, index) {
   return section > 0 ? `${section}.${index}` : String(index);
 }
 
+/** The positional anchor id for an unkeyed equation, e.g. `2.4` → `eq-2-4`. */
+export function equationAnchorId({ key, number }) {
+  return key ? `eq-${key}` : `eq-${String(number).replace(/\./g, '-')}`;
+}
+
 function stripFencedCode(markdown) {
   return String(markdown)
     .replace(/```[\s\S]*?```/g, (block) => block.replace(/[^\n]/g, ' '))
@@ -63,13 +70,29 @@ function stripFencedCode(markdown) {
     .replace(/(^|[^`])`[^`\n]*`/g, (match) => match.replace(/[^\n]/g, ' '));
 }
 
+/**
+ * Blank the body of every block-level MDX component (`<Capitalised …> … </…>`)
+ * so a `$$…$$` used to illustrate a worked example inside `<CompactExample>`
+ * (or an `<Aside>`, etc.) is not counted as a lesson-body equation. The
+ * outermost match wins, so nested components are blanked in one pass;
+ * newlines are kept so line/section structure is unchanged.
+ */
+function stripJsxComponents(markdown) {
+  return String(markdown).replace(
+    /<([A-Z][A-Za-z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g,
+    (block) => block.replace(/[^\n]/g, ' '),
+  );
+}
+
 /**
  * Every keyed display equation in a Markdown body, in appearance order, with
  * its assigned number. `$$…$$` blocks only; `##` headings between them advance
- * the section counter.
+ * the section counter. Every display block advances the in-section index, so a
+ * keyed equation's number reflects its position among *all* display equations,
+ * not only the keyed ones.
  */
 export function scanEquationLabels(markdown) {
-  const text = stripFencedCode(markdown);
+  const text = stripJsxComponents(stripFencedCode(markdown));
   const tokens = [];
   const heading = /^[ \t]{0,3}##[ \t]+\S/gm;
   const display = /\$\$([\s\S]+?)\$\$/g;
@@ -79,9 +102,11 @@ export function scanEquationLabels(markdown) {
   for (const match of text.matchAll(display)) {
     EQ_LABEL_PATTERN.lastIndex = 0;
     const label = EQ_LABEL_PATTERN.exec(match[1]);
-    if (label) {
-      tokens.push({ kind: 'equation', index: match.index, key: label[1] });
-    }
+    tokens.push({
+      kind: 'equation',
+      index: match.index,
+      key: label ? label[1] : null,
+    });
   }
   tokens.sort((a, b) => a.index - b.index);
 
@@ -95,6 +120,7 @@ export function scanEquationLabels(markdown) {
       continue;
     }
     indexInSection += 1;
+    if (token.key == null) continue;
     labels.push({
       key: token.key,
       number: equationNumber(section, indexInSection),
@@ -106,39 +132,49 @@ export function scanEquationLabels(markdown) {
 }
 
 /**
- * The mdast equivalent of `scanEquationLabels`: walk the tree in document
- * order, advancing the section counter on every depth-2 heading and emitting a
- * label for every `math` node whose source carries `\label{eq:…}`.
+ * 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`.
  */
-export function collectEquationLabels(tree) {
-  const labels = [];
+export function collectDisplayEquations(tree) {
+  const equations = [];
   let section = 0;
   let indexInSection = 0;
 
-  const walk = (node) => {
-    if (!node || typeof node !== 'object') return;
+  // Only top-level blocks: a `$$…$$` nested in an MDX component (a
+  // `<CompactExample>` worked example, an `<Aside>`) is illustrative, not part
+  // of the lesson's equation sequence, and its container may be collapsed.
+  const children = Array.isArray(tree?.children) ? tree.children : [];
+  for (const node of children) {
+    if (!node || typeof node !== 'object') continue;
     if (node.type === 'heading' && node.depth === 2) {
       section += 1;
       indexInSection = 0;
-      return;
+      continue;
     }
     if (node.type === 'math') {
+      indexInSection += 1;
       EQ_LABEL_PATTERN.lastIndex = 0;
       const label = EQ_LABEL_PATTERN.exec(String(node.value ?? ''));
-      if (label) {
-        indexInSection += 1;
-        labels.push({
-          key: label[1],
-          number: equationNumber(section, indexInSection),
-          section,
-          indexInSection,
-          node,
-        });
-      }
-      return;
+      equations.push({
+        key: label ? label[1] : null,
+        number: equationNumber(section, indexInSection),
+        section,
+        indexInSection,
+        node,
+      });
     }
-    if (Array.isArray(node.children)) node.children.forEach(walk);
-  };
-  walk(tree);
-  return labels;
+  }
+  return equations;
+}
+
+/**
+ * The keyed subset of `collectDisplayEquations` — the tree-walk counterpart of
+ * `scanEquationLabels`. Numbers reflect position among all display equations.
+ */
+export function collectEquationLabels(tree) {
+  return collectDisplayEquations(tree).filter(
+    (equation) => equation.key != null,
+  );
 }

package/dist/reference/gate-math.d.ts

@@ -4,10 +4,11 @@ interface MathGateDiagnostic {
     readonly context: 'body' | 'formula' | 'assessment';
     /**
      * Body / component-slot math blocks the build (the render path needs every
-     * glyph resolved for the KaTeX trust callback). `formula` and `assessment`
-     * math enter as warnings (Tier 3) and are promoted once existing content is
-     * brought into line — they surface pre-existing ambiguities that are a
-     * separate reviewed content pass (D6/D13/D14), not a D3 codemod.
+     * glyph resolved for the KaTeX trust callback). `formula` joined it at D15:
+     * a formula's glyphs are now rendered live and explorable, so an unresolved
+     * one is a hole the reader can see, and the corpus was brought to zero when
+     * the tier was promoted. `assessment` math stays a Tier-3 warning until its
+     * own reviewed content pass (D6/D13/D14).
      */
     readonly severity: 'error' | 'warning';
     readonly file: string;

package/dist/reference/gate-math.js

@@ -1,8 +1,9 @@
 import { resolveMathGlyphs, GlyphResolutionError } from "./math-glyphs.mjs";
 import { stripEquationLabels } from "./equations.mjs";
+import { formulaGlyphScope, unknownFormulaScopeKeys } from "./gloss.js";
 const SEVERITY = {
   body: "error",
-  formula: "warning",
+  formula: "error",
   assessment: "warning"
 };
 const TERM_KEY = /\[\[\s*([a-z0-9]+(?:[.-][a-z0-9]+)*)\s*\]\]/g;
@@ -75,6 +76,33 @@ function resolveInto(latex, scope, context, file, line, fix, out) {
   }
 }
 const BODY_FIX = "Introduce the symbol with [[key]], define it in notation.local, or wrap it in \\explain{key}{latex}.";
+function dedupeScope(scope) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const entry of scope) {
+    if (seen.has(entry.key)) continue;
+    seen.add(entry.key);
+    out.push(entry);
+  }
+  return out;
+}
+function reportUnknownScopeKeys(definition, cardKeys, file, out) {
+  const glossKeys = new Set(definition.glosses.map((gloss) => gloss.key));
+  for (const key of unknownFormulaScopeKeys(
+    definition.formula,
+    glossKeys,
+    cardKeys
+  )) {
+    out.push({
+      context: "formula",
+      severity: SEVERITY.formula,
+      file,
+      token: key,
+      message: `${definition.key} formula names unknown notation key ${JSON.stringify(key)}. Name an existing card, or declare the symbol under glosses: on this entry.`
+    });
+  }
+}
+const SHARED_FORMULA_FIX = "Every symbol in a notation entry formula must resolve to the entry itself, one of its glosses:, a card the formula names with \\explain{key}{latex}, or the base library.";
 const FORMULA_FIX = "Every right-hand-side variable of a notation.local formula must resolve to the entry key, another page symbol, or the base library.";
 const ASSESSMENT_FIX = "Introduce the symbol in the owning lesson's prose with [[key]], or wrap it in \\explain{key}{latex}.";
 function gateContentMath(input) {
@@ -85,6 +113,18 @@ function gateContentMath(input) {
       definition
     ])
   );
+  const sharedCards = new Map(
+    notationInput.sharedDefinitions.map((definition) => [
+      definition.key,
+      { key: definition.key, notation: definition.notation }
+    ])
+  );
+  const cardKeys = /* @__PURE__ */ new Set([
+    ...sharedCards.keys(),
+    ...notationInput.lessons.flatMap(
+      (lesson) => lesson.localDefinitions.map((definition) => definition.key)
+    )
+  ]);
   const lessonById = new Map(
     notationInput.lessons.map((lesson) => [lesson.lessonId, lesson])
   );
@@ -110,15 +150,46 @@ function gateContentMath(input) {
       if (!definition.formula) continue;
       resolveInto(
         definition.formula,
-        scope,
+        dedupeScope([
+          ...scope,
+          ...definition.glosses.map((gloss) => ({
+            key: gloss.key,
+            notation: gloss.notation
+          }))
+        ]),
         "formula",
         file,
         void 0,
         FORMULA_FIX,
         diagnostics
       );
+      reportUnknownScopeKeys(definition, cardKeys, file, diagnostics);
     }
   }
+  for (const definition of notationInput.sharedDefinitions) {
+    if (!definition.formula) continue;
+    resolveInto(
+      definition.formula,
+      formulaGlyphScope({
+        key: definition.key,
+        notation: definition.notation,
+        formula: definition.formula,
+        glosses: definition.glosses,
+        cardsByKey: sharedCards
+      }),
+      "formula",
+      definition.source.file,
+      void 0,
+      SHARED_FORMULA_FIX,
+      diagnostics
+    );
+    reportUnknownScopeKeys(
+      definition,
+      cardKeys,
+      definition.source.file,
+      diagnostics
+    );
+  }
   for (const link of lessonAssessments) {
     const lesson = lessonById.get(link.lessonId);
     if (!lesson) continue;

package/dist/reference/gloss.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Glosses and formula scope (D15) — the second tier of the notation
+ * vocabulary.
+ *
+ * A **card** is a `content/notation/*.md` entry (or a `notation.local` entry):
+ * symbol, name, description, units, sources, curriculum alignment, review
+ * state. It gets a glossary card and is a node in the curriculum graph.
+ *
+ * A **gloss** is declared on a card, in that card's `glosses:` frontmatter,
+ * and carries a symbol, a name, and optionally a bare units string. It exists
+ * for one reason: so a card's rigorous `formula` can name its own letters
+ * without each letter having to become a card. A gloss has no description, no
+ * sources, no alignment, no review state, and no glossary card — and, the
+ * point of the whole tier, **it creates no curriculum edge**. A card that
+ * dragged its formula's letters into the registry would drag them into the
+ * lesson bundle of every lesson that uses it, and a foundations lesson would
+ * fail `alignment-introduction` on a symbol introduced six lessons later.
+ *
+ * The editorial convention (not enforced here): a card's formula may introduce
+ * glosses; glosses terminate — they have no formula of their own. A symbol
+ * that later needs a real definition is **promoted**: delete the gloss line,
+ * add `content/notation/<key>.md`. Because a formula spells LaTeX and never a
+ * key, nothing else in the corpus changes.
+ */
+interface NotationGlossInput {
+    readonly latex: string;
+    readonly name: string;
+    readonly units?: string;
+}
+/** A gloss with its derived key and display label. */
+interface ResolvedGloss {
+    /** `<card key>.<slug(name)>` — derived, never authored. */
+    readonly key: string;
+    readonly notation: string;
+    readonly label: string;
+    readonly units?: string;
+    /** The card that declares it. */
+    readonly ownerKey: string;
+}
+/** One `{key, notation}` row of the flat table `resolveMathGlyphs` consumes. */
+interface GlyphScopeEntry {
+    readonly key: string;
+    readonly notation: string;
+}
+/**
+ * The key segment derived from a gloss name: lower-cased, runs of anything
+ * that is not a letter or digit collapsed to a single `-`. Returns `undefined`
+ * when the name has no usable characters, so the schema can reject it rather
+ * than the loader minting an invalid key.
+ */
+declare function glossKeySegment(name: string): string | undefined;
+/**
+ * Derive a gloss's key. Dotted onto the owning card's key, so a gloss is
+ * entry-scoped by construction: two cards may each gloss `T`, and a gloss can
+ * never be confused with a card in the flat registry.
+ */
+declare function glossKey(ownerKey: string, name: string): string;
+/** Resolve a card's authored `glosses:` list into keyed, labelled entries. */
+declare function resolveGlosses(ownerKey: string, glosses: readonly NotationGlossInput[]): ResolvedGloss[];
+declare function formulaExplainKeys(formula: string): string[];
+/**
+ * The glyph table a card's `formula` resolves against:
+ *
+ *     {the card itself} ∪ {its glosses} ∪ {cards its formula names} ∪ base library
+ *
+ * Narrower than the registry-wide table a card's *body* math still uses, and
+ * narrower than a lesson page's scope. A card named with `\explain{key}` in
+ * the formula joins the table for glyph resolution **only**: its existence is
+ * checked, but it deliberately becomes no reference edge, because a
+ * definitional letter is not a curriculum prerequisite. See the module note.
+ */
+declare function formulaGlyphScope(input: {
+    readonly key: string;
+    readonly notation: string;
+    readonly formula?: string;
+    readonly glosses: readonly ResolvedGloss[];
+    /** Every card by key — shared entries, plus page-local ones for a lesson. */
+    readonly cardsByKey: ReadonlyMap<string, GlyphScopeEntry>;
+}): GlyphScopeEntry[];
+/**
+ * Keys named by a formula that no card defines. The build reports these — an
+ * `\explain{…}` pointing at nothing is an authoring mistake, not a silent
+ * fallback to an unresolved glyph.
+ */
+declare function unknownFormulaScopeKeys(formula: string | undefined, glossKeys: ReadonlySet<string>, cardKeys: ReadonlySet<string>): string[];
+
+export { type GlyphScopeEntry, type NotationGlossInput, type ResolvedGloss, formulaExplainKeys, formulaGlyphScope, glossKey, glossKeySegment, resolveGlosses, unknownFormulaScopeKeys };

package/dist/reference/gloss.js

@@ -0,0 +1,59 @@
+function glossKeySegment(name) {
+  const segment = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return segment.length > 0 ? segment : void 0;
+}
+function glossKey(ownerKey, name) {
+  const segment = glossKeySegment(name);
+  if (segment === void 0) {
+    throw new Error(
+      `Gloss name ${JSON.stringify(name)} on ${ownerKey} yields no key segment.`
+    );
+  }
+  return `${ownerKey}.${segment}`;
+}
+function resolveGlosses(ownerKey, glosses) {
+  return glosses.map((gloss) => ({
+    key: glossKey(ownerKey, gloss.name),
+    notation: gloss.latex,
+    label: gloss.name,
+    ownerKey,
+    ...gloss.units === void 0 ? {} : { units: gloss.units }
+  }));
+}
+const EXPLAIN_KEY = /\\explain\s*\{([a-z0-9]+(?:[.-][a-z0-9]+)*)\}/g;
+function formulaExplainKeys(formula) {
+  EXPLAIN_KEY.lastIndex = 0;
+  return [...formula.matchAll(EXPLAIN_KEY)].map((match) => match[1] ?? "");
+}
+function formulaGlyphScope(input) {
+  const scope = [
+    { key: input.key, notation: input.notation }
+  ];
+  const seen = /* @__PURE__ */ new Set([input.key]);
+  for (const gloss of input.glosses) {
+    if (seen.has(gloss.key)) continue;
+    seen.add(gloss.key);
+    scope.push({ key: gloss.key, notation: gloss.notation });
+  }
+  for (const key of formulaExplainKeys(input.formula ?? "")) {
+    if (seen.has(key)) continue;
+    const card = input.cardsByKey.get(key);
+    if (!card) continue;
+    seen.add(key);
+    scope.push({ key: card.key, notation: card.notation });
+  }
+  return scope;
+}
+function unknownFormulaScopeKeys(formula, glossKeys, cardKeys) {
+  return formulaExplainKeys(formula ?? "").filter(
+    (key) => !cardKeys.has(key) && !glossKeys.has(key)
+  );
+}
+export {
+  formulaExplainKeys,
+  formulaGlyphScope,
+  glossKey,
+  glossKeySegment,
+  resolveGlosses,
+  unknownFormulaScopeKeys
+};

package/dist/reference/katex-options.d.mts

@@ -0,0 +1,33 @@
+/**
+ * KaTeX trust callback that permits exactly one inert marker attribute:
+ * `data-notation-key` (a registry key) or `data-lab-slot` (a lab value hole).
+ * Links, styles, classes, IDs, protocols, and every other data attribute stay
+ * untrusted. Key existence is checked by the remark adapter, the lab-math
+ * renderer, and the workspace validator before KaTeX runs.
+ */
+export function trustNotationMarker(context: any): boolean;
+/**
+ * Add non-security KaTeX settings while keeping the notation macros and trust
+ * boundary non-overridable.
+ */
+export function createNotationKatexOptions(overrides?: {}): {
+    output: "htmlAndMathml";
+    throwOnError: true;
+    trust: typeof trustNotationMarker;
+    macros: any;
+    strict: typeof strictNotation;
+};
+export const EXPLAIN_MACRO: string;
+export const SLOT_MACRO: string;
+export const notationKatexOptions: Readonly<{
+    output: "htmlAndMathml";
+    throwOnError: true;
+    strict: typeof strictNotation;
+    trust: typeof trustNotationMarker;
+    macros: Readonly<{
+        '\\explain': string;
+        '\\slot': string;
+    }>;
+}>;
+declare function strictNotation(errorCode: any): "ignore" | "warn";
+export {};

package/dist/reference/lab-math-scope.js

@@ -1,4 +1,4 @@
-import { loadManifest } from "../compiler/manifest";
+import { loadManifest } from "../compiler/manifest.js";
 const TERM_KEY = /\[\[\s*([a-z0-9]+(?:[.-][a-z0-9]+)*)\s*\]\]/g;
 const EXPLAIN_KEY = /\\explain\s*\{([a-z0-9]+(?:[.-][a-z0-9]+)*)\}/g;
 async function labMathScope(notation, body = "") {

package/dist/reference/math-glyphs.d.mts

@@ -0,0 +1,46 @@
+/**
+ * Resolve and annotate one KaTeX expression against a page's flat glyph table.
+ * Source offsets in the result always refer to the original, unmodified LaTeX.
+ *
+ * @param {string} latex
+ * @param {Array<{key: string, notation: string}>} definitions
+ */
+export function resolveMathGlyphs(latex: string, definitions: Array<{
+    key: string;
+    notation: string;
+}>): {
+    latex: string;
+    bindings: {
+        key: any;
+        level: any;
+        match: any;
+        token: any;
+    }[];
+    unresolved: any;
+};
+/**
+ * Page-level glyph-map resolver (cleanup plan, D1 decision 2026-09-02).
+ *
+ * A page declares its glyphs once — `notation.local` plus the shared entries it
+ * introduces in prose with `[[key]]` — so the glyph table handed in here is a
+ * flat list with **one meaning per glyph**. This module parses one `$…$` /
+ * `$$…$$` expression, matches each declared symbol against it (whole canonical
+ * form first, then a unique base glyph for a shorter or instantiated form),
+ * marks every match with a validated `\explain` marker, and reports any
+ * remaining identifier atom so the caller can fail at `file:line:token`.
+ * `\explain{key}{latex}` in the source stays as the escape hatch for a
+ * compound or glyph-colliding symbol.
+ *
+ * Because the table is unambiguous, matching is a lookup, not a search: no
+ * cross-definition candidate solving, no ambiguity permutation. What remains is
+ * the tokenizer the page-glyph-map syntax requires — a KaTeX parse plus the
+ * structural signatures that let `CF_k` be found as a three-node run and `D` be
+ * found as the head of `D(0,2)`. `katex.__parse` is that tokenizer; the version
+ * guard below keeps a dependency bump from silently changing its tree.
+ */
+export const SUPPORTED_KATEX_PARSE_VERSION: "0.16.47";
+export class GlyphResolutionError extends Error {
+    constructor(code: any, message: any, details?: undefined);
+    code: any;
+    details: any;
+}

package/dist/reference/registry.js

@@ -5,7 +5,7 @@ import {
   localDefinitionId,
   resolveReferenceId,
   sharedDefinitionId
-} from "./references";
+} from "./references.js";
 function buildNotationRegistry(rawInput) {
   const diagnostics = [];
   const lessons = buildLessonIndex(rawInput.lessons, diagnostics);
@@ -15,6 +15,7 @@ function buildNotationRegistry(rawInput) {
     diagnostics
   );
   const availableDefinitionIds = new Set(definitions.keys());
+  validateGlossKeys(definitions, diagnostics);
   for (const candidate of definitions.values()) {
     const references = sortedReferences(candidate.input.references);
     const resolved = [];
@@ -298,6 +299,26 @@ function normalizeLocalDefinition(input) {
     references: sortedReferences(input.references)
   };
 }
+function validateGlossKeys(definitions, diagnostics) {
+  const cardKeys = new Set(
+    [...definitions.values()].map((candidate) => candidate.input.key)
+  );
+  for (const candidate of definitions.values()) {
+    for (const gloss of candidate.input.glosses) {
+      if (!cardKeys.has(gloss.key)) continue;
+      diagnostics.push(
+        diagnostic({
+          code: "gloss-collides-with-card",
+          message: `${candidate.id} glosses ${JSON.stringify(gloss.label)} as ${gloss.key}, which is also a notation card; delete the gloss or rename it`,
+          key: gloss.key,
+          lessonId: candidate.kind === "local" ? candidate.lesson.lessonId : void 0,
+          definitionId: candidate.id,
+          source: candidate.input.source
+        })
+      );
+    }
+  }
+}
 function validateReferenceKey(reference, owner, diagnostics) {
   if (isNotationKey(reference.key)) return true;
   diagnostics.push(
@@ -371,6 +392,7 @@ function toDefinitionRecord(candidate) {
       status: input2.status,
       aiAssisted: input2.aiAssisted,
       body: input2.body,
+      glosses: input2.glosses,
       source: input2.source,
       resolvedReferences: candidate.resolvedReferences,
       ...input2.formula === void 0 ? {} : { formula: input2.formula },
@@ -392,6 +414,7 @@ function toDefinitionRecord(candidate) {
     seeAlso: input.seeAlso,
     alignment: input.alignment,
     status: candidate.lesson.status,
+    glosses: input.glosses,
     source: input.source,
     resolvedReferences: candidate.resolvedReferences,
     ...input.formula === void 0 ? {} : { formula: input.formula },
@@ -432,6 +455,7 @@ function definitionFingerprint(candidate) {
       status: input2.status,
       aiAssisted: input2.aiAssisted,
       body: normalizeText(input2.body),
+      glosses: input2.glosses,
       references
     });
   }
@@ -447,6 +471,7 @@ function definitionFingerprint(candidate) {
     sources: [...input.sources].sort(),
     seeAlso: [...input.seeAlso].sort(),
     alignment,
+    glosses: input.glosses,
     references
   });
 }

package/dist/reference/rehype-fail-katex-errors.d.mts

@@ -0,0 +1,6 @@
+/**
+ * rehype-katex reports parse failures as non-fatal VFile messages and renders
+ * a `.katex-error` fallback. Turn those recovered failures into compiler
+ * errors so Astro cannot successfully build a lesson containing broken math.
+ */
+export default function rehypeFailKatexErrors(): (tree: any, file: any) => void;

package/dist/reference/rehype-heading-anchors.d.mts

@@ -0,0 +1 @@
+export default function rehypeHeadingAnchors(): (tree: any, file: any) => void;