explico 0.1.1 → 0.2.0

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/registry.js

@@ -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-heading-anchors.d.mts

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

package/dist/reference/rehype-heading-anchors.mjs

@@ -0,0 +1,144 @@
+/**
+ * Deep-linkable content headings (Step F3).
+ *
+ * The lesson pipeline uses a custom Markdown `processor` (see `astro.config.mjs`),
+ * which bypasses Starlight's own heading-link rehype pass. This plugin restores
+ * it with the *same* markup Starlight emits, so its bundled `anchor-links.css`
+ * (shipped globally because `markdown.headingLinks` defaults on) styles it for
+ * free — including the hover/focus reveal of an otherwise invisible anchor:
+ *
+ *   <div class="sl-heading-wrapper level-h2">
+ *     <h2 id="slug">Heading</h2>
+ *     <a class="sl-anchor-link" href="#slug"> <icon> <sr-only label> </a>
+ *   </div>
+ *
+ * The `:target` flash, sticky-header scroll offset, and the JS niceties
+ * (re-trigger on repeat activation, smooth scroll, `history.pushState`, brief
+ * section highlight) live in `global.css` + `HeadingAnchorEnhancer.astro`, the
+ * same split the keyed-equation feature uses.
+ *
+ * `rehypeHeadingIds` from `@astrojs/markdown-remark` normally runs *after* the
+ * user rehype plugins, so heading `id`s do not exist yet when this runs. It is
+ * idempotent (only assigns a missing `id`, and rebuilds `file.data.astro.headings`
+ * from an unchanged document order), so this plugin runs it first and Astro's
+ * later pass becomes a no-op for these headings.
+ */
+
+import { rehypeHeadingIds } from '@astrojs/markdown-remark';
+
+const HEADING_TAG = /^h([1-6])$/;
+
+// Starlight's `link-alt` icon (`components-internals/Icons.ts`), the same glyph
+// its own `rehypeAutolinkHeadings` uses.
+const LINK_ICON_PATH =
+  'm12.11 15.39-3.88 3.88a2.52 2.52 0 0 1-3.5 0 2.47 2.47 0 0 1 0-3.5l3.88-3.88a1 1 0 1 0-1.42-1.42l-3.88 3.89a4.48 4.48 0 0 0 6.33 6.33l3.89-3.88a1 1 0 0 0-1.42-1.42m8.58-12.08a4.49 4.49 0 0 0-6.33 0l-3.89 3.88a1 1 0 1 0 1.42 1.42l3.88-3.88a2.52 2.52 0 0 1 3.5 0 2.47 2.47 0 0 1 0 3.5l-3.88 3.88a1 1 0 0 0 0 1.42 1 1 0 0 0 1.42 0l3.88-3.89a4.49 4.49 0 0 0 0-6.33M8.83 15.17a1 1 0 0 0 .71.29 1 1 0 0 0 .71-.29l4.92-4.92a1 1 0 1 0-1.42-1.42l-4.92 4.92a1 1 0 0 0 0 1.42';
+
+function headingText(node) {
+  let text = '';
+  const walk = (current) => {
+    if (!current || typeof current !== 'object') return;
+    if (current.type === 'text' || current.type === 'raw') {
+      text += String(current.value ?? '');
+      return;
+    }
+    if (Array.isArray(current.children)) current.children.forEach(walk);
+  };
+  walk(node);
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function isHeadingWrapper(node) {
+  const className = node?.properties?.className;
+  return (
+    node?.type === 'element' &&
+    Array.isArray(className) &&
+    className.includes('sl-heading-wrapper')
+  );
+}
+
+function anchorLink(id, label) {
+  return {
+    type: 'element',
+    tagName: 'a',
+    properties: { className: ['sl-anchor-link'], href: `#${id}` },
+    children: [
+      {
+        type: 'element',
+        tagName: 'span',
+        properties: { ariaHidden: 'true', className: ['sl-anchor-icon'] },
+        children: [
+          {
+            type: 'element',
+            tagName: 'svg',
+            properties: {
+              width: 16,
+              height: 16,
+              viewBox: '0 0 24 24',
+              fill: 'currentColor',
+            },
+            children: [
+              {
+                type: 'element',
+                tagName: 'path',
+                properties: { d: LINK_ICON_PATH },
+                children: [],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        type: 'element',
+        tagName: 'span',
+        properties: { className: ['sr-only'], 'data-pagefind-ignore': 'true' },
+        children: [{ type: 'text', value: label }],
+      },
+    ],
+  };
+}
+
+export default function rehypeHeadingAnchors() {
+  const assignHeadingIds = rehypeHeadingIds();
+
+  return function transform(tree, file) {
+    assignHeadingIds(tree, file);
+
+    const walk = (node) => {
+      if (!node || typeof node !== 'object' || !Array.isArray(node.children)) {
+        return;
+      }
+      if (isHeadingWrapper(node)) return; // already processed
+
+      for (let index = 0; index < node.children.length; index++) {
+        const child = node.children[index];
+        const tag =
+          child?.type === 'element' && typeof child.tagName === 'string'
+            ? HEADING_TAG.exec(child.tagName)
+            : null;
+
+        if (
+          tag &&
+          tag[1] !== '1' &&
+          typeof child.properties?.id === 'string' &&
+          child.properties.id.length > 0
+        ) {
+          const id = child.properties.id;
+          const label = `Section titled “${headingText(child)}”`;
+          node.children[index] = {
+            type: 'element',
+            tagName: 'div',
+            properties: {
+              className: ['sl-heading-wrapper', `level-${child.tagName}`],
+            },
+            children: [child, anchorLink(id, label)],
+          };
+          continue; // the heading is a leaf for our purposes
+        }
+
+        walk(child);
+      }
+    };
+
+    walk(tree);
+  };
+}

package/dist/reference/remark-notation.mjs

@@ -36,7 +36,9 @@ export const NOTATION_KEY_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
 import { GlyphResolutionError, resolveMathGlyphs } from './math-glyphs.mjs';
 import {
   EQ_LABEL_PATTERN,
+  collectDisplayEquations,
   collectEquationLabels,
+  equationAnchorId,
   parseEquationRef,
   stripEquationLabels,
 } from './equations.mjs';
@@ -307,28 +309,31 @@ function defaultHref(definition, key, base = '') {
 }
 
 /**
- * Wrap a keyed `$$…$$` `math` node so the container survives `rehype-katex`
- * (which splices the inner `math-display` element out). The visible number is
- * a focusable `<a>` sibling — never authored, never inside KaTeX — so it
- * survives print and screen readers name it "Equation 2.4".
+ * Wrap a display `$$…$$` `math` node so the container survives `rehype-katex`
+ * (which splices the inner `math-display` element out). Every display equation
+ * in a lesson is numbered; a keyed one anchors at `#eq-<key>`, an unkeyed one
+ * at its positional `#eq-<section>-<index>`. The visible number is a focusable
+ * `<a>` sibling — never authored, never inside KaTeX — so it survives print and
+ * screen readers name it "Equation 2.4".
  */
-function keyedEquationNode(mathNode, key, number) {
+function equationNode(mathNode, { key, number }) {
+  const id = equationAnchorId({ key, number });
+  const hProperties = {
+    id,
+    className: ['keyed-equation'],
+    'data-eq-number': number,
+  };
+  if (key) hProperties['data-eq-key'] = key;
+  else hProperties['data-eq-auto'] = '';
+
   return {
     type: 'paragraph',
-    data: {
-      hName: 'div',
-      hProperties: {
-        id: `eq-${key}`,
-        className: ['keyed-equation'],
-        'data-eq-key': key,
-        'data-eq-number': number,
-      },
-    },
+    data: { hName: 'div', hProperties },
     children: [
       mathNode,
       {
         type: 'link',
-        url: `#eq-${key}`,
+        url: `#${id}`,
         children: [{ type: 'text', value: `(${number})` }],
         data: {
           hProperties: {
@@ -598,6 +603,14 @@ export default function remarkNotation(options = {}) {
       crossPage: options.equations ?? {},
     };
 
+    // 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 equationByNode = new Map(
+      displayEquations.map((equation) => [equation.node, equation]),
+    );
+
     const resolve = (key, kind, node) => {
       const context = {
         file,
@@ -647,7 +660,6 @@ export default function remarkNotation(options = {}) {
               node,
             );
           }
-          node.__eqKey = labelMatch[1];
           value = stripEquationLabels(value);
           replaceMathSource(node, value);
         }
@@ -725,14 +737,8 @@ export default function remarkNotation(options = {}) {
           continue;
         }
         visit(child, false);
-        if (child && child.__eqKey) {
-          const key = child.__eqKey;
-          delete child.__eqKey;
-          node.children[index] = keyedEquationNode(
-            child,
-            key,
-            pageLabels.get(key),
-          );
+        if (child && child.type === 'math' && equationByNode.has(child)) {
+          node.children[index] = equationNode(child, equationByNode.get(child));
         }
       }
     };

package/dist/reference/types.d.ts

@@ -15,6 +15,19 @@ type NotationAlignment = {
     readonly rationale: string;
 };
 type NotationReferenceKind = 'prose' | 'math' | 'definition';
+/**
+ * A gloss resolved by the loader (D15). Declared on a card, keyed
+ * `<card key>.<slug(name)>`, and deliberately absent from the registry: a
+ * gloss is never a definition record, never a reference target, and never a
+ * curriculum node. See `reference/gloss.ts`.
+ */
+interface NotationGlossEntry {
+    readonly key: string;
+    readonly notation: string;
+    readonly label: string;
+    readonly units?: string;
+    readonly ownerKey: string;
+}
 interface NotationReferenceInput {
     readonly key: string;
     readonly kind: NotationReferenceKind;
@@ -37,6 +50,8 @@ interface SharedNotationDefinitionInput {
     readonly body: string;
     /** References harvested from the Markdown body. */
     readonly references: readonly NotationReferenceInput[];
+    /** Symbols this entry's `formula` names but does not make cards of. */
+    readonly glosses: readonly NotationGlossEntry[];
     readonly source: SourceSpan;
 }
 interface LocalNotationDefinitionInput {
@@ -51,6 +66,8 @@ interface LocalNotationDefinitionInput {
     readonly alignment: NotationAlignment;
     /** References harvested from summary content. */
     readonly references: readonly NotationReferenceInput[];
+    /** Symbols this entry's `formula` names but does not make cards of. */
+    readonly glosses: readonly NotationGlossEntry[];
     readonly source: SourceSpan;
 }
 interface NotationLessonInput {
@@ -67,7 +84,7 @@ interface NotationRegistryInput {
     readonly sharedDefinitions: readonly SharedNotationDefinitionInput[];
     readonly lessons: readonly NotationLessonInput[];
 }
-type NotationDiagnosticCode = 'invalid-key' | 'duplicate-page' | 'duplicate-definition' | 'conflicting-definition' | 'undefined-reference' | 'reference-cycle' | 'unused-definition' | 'alignment-unknown-competency' | 'alignment-unknown-lesson' | 'alignment-introduction' | 'alignment-unavailable' | 'alignment-review-state';
+type NotationDiagnosticCode = 'invalid-key' | 'duplicate-page' | 'duplicate-definition' | 'conflicting-definition' | 'undefined-reference' | 'reference-cycle' | 'unused-definition' | 'alignment-unknown-competency' | 'alignment-unknown-lesson' | 'alignment-introduction' | 'alignment-unavailable' | 'alignment-review-state' | 'gloss-collides-with-card';
 type DiagnosticSeverity = 'error' | 'warning';
 interface NotationDiagnostic {
     readonly code: NotationDiagnosticCode;
@@ -95,6 +112,12 @@ interface ResolvedNotationReference {
 interface NotationDefinitionRecordBase {
     readonly id: string;
     readonly key: string;
+    /**
+     * Symbols this entry's `formula` names but does not make cards of (D15).
+     * Carried on the record so the manifest can build the entry-scoped formula
+     * table; deliberately **not** a definition, a reference target, or an edge.
+     */
+    readonly glosses: readonly NotationGlossEntry[];
     readonly scope: NotationDefinitionScope;
     readonly notation: string;
     readonly label: string;
@@ -148,4 +171,4 @@ interface NotationRegistry {
     readonly diagnostics: readonly NotationDiagnostic[];
 }
 
-export type { DiagnosticSeverity, EditorialStatus, LocalNotationDefinitionInput, LocalNotationDefinitionRecord, NotationAlignment, NotationBacklink, NotationBinding, NotationDefinitionRecord, NotationDefinitionScope, NotationDiagnostic, NotationDiagnosticCode, NotationLessonInput, NotationPageBundle, NotationReferenceInput, NotationReferenceKind, NotationRegistry, NotationRegistryInput, ResolvedNotationReference, SharedNotationDefinitionInput, SharedNotationDefinitionRecord, SourceSpan };
+export type { DiagnosticSeverity, EditorialStatus, LocalNotationDefinitionInput, LocalNotationDefinitionRecord, NotationAlignment, NotationBacklink, NotationBinding, NotationDefinitionRecord, NotationDefinitionScope, NotationDiagnostic, NotationDiagnosticCode, NotationGlossEntry, NotationLessonInput, NotationPageBundle, NotationReferenceInput, NotationReferenceKind, NotationRegistry, NotationRegistryInput, ResolvedNotationReference, SharedNotationDefinitionInput, SharedNotationDefinitionRecord, SourceSpan };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explico",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Build-time engine for prerequisite-aware, notation-rigorous course content: one validated content model, a semantic notation/citation/equation system with a completeness gate, and a deterministic JSON manifest.",
   "type": "module",
   "license": "UNLICENSED",