explico 0.6.0 → 0.7.0

package/src/reference/delimiter-size.ts

@@ -0,0 +1,301 @@
+/**
+ * Rule N17: nested scalable delimiters must make their hierarchy visible.
+ *
+ * This deliberately parses only sizing syntax. It does not decide whether a
+ * parenthesis, bracket, or brace is semantic, and it never recommends changing
+ * one delimiter shape into another. N16's alternating-shape preference remains
+ * a review-only authoring concern.
+ */
+
+export const DELIMITER_SIZE_DIAGNOSTIC_CODE =
+  'delimiter-size-hierarchy' as const;
+
+export type DelimiterSizeName =
+  | 'automatic'
+  | 'big'
+  | 'Big'
+  | 'bigg'
+  | 'Bigg';
+
+export interface DelimiterSizeSuggestion {
+  readonly size: Exclude<DelimiterSizeName, 'automatic' | 'big'>;
+  readonly open: string;
+  readonly close: string;
+  readonly latex: string;
+}
+
+export interface DelimiterSizeDiagnostic {
+  readonly code: typeof DELIMITER_SIZE_DIAGNOSTIC_CODE;
+  readonly severity: 'warning';
+  readonly offset: number;
+  readonly line: number;
+  readonly column: number;
+  readonly outerSize: DelimiterSizeName;
+  readonly nestedSize: DelimiterSizeName;
+  readonly suggestion?: DelimiterSizeSuggestion;
+  readonly message: string;
+}
+
+type TokenKind = 'open' | 'close';
+type PairKind = 'automatic' | 'manual';
+
+interface SizeSpec {
+  readonly name: DelimiterSizeName;
+  /** `\left` and `\big` can be visually equivalent, so share level 1. */
+  readonly rank: number;
+  readonly openCommand: string;
+  readonly closeCommand: string;
+  readonly kind: PairKind;
+}
+
+interface DelimiterToken {
+  readonly kind: TokenKind;
+  readonly pairKind: PairKind;
+  readonly rank: number;
+  readonly size: DelimiterSizeName;
+  readonly delimiter: string;
+  readonly offset: number;
+  readonly end: number;
+}
+
+interface DelimiterPair {
+  readonly open: DelimiterToken;
+  close?: DelimiterToken;
+  readonly children: DelimiterPair[];
+  requiredRank?: number;
+}
+
+const SIZE_SPECS: readonly SizeSpec[] = [
+  {
+    name: 'automatic',
+    rank: 1,
+    openCommand: '\\left',
+    closeCommand: '\\right',
+    kind: 'automatic',
+  },
+  {
+    name: 'big',
+    rank: 1,
+    openCommand: '\\bigl',
+    closeCommand: '\\bigr',
+    kind: 'manual',
+  },
+  {
+    name: 'Big',
+    rank: 2,
+    openCommand: '\\Bigl',
+    closeCommand: '\\Bigr',
+    kind: 'manual',
+  },
+  {
+    name: 'bigg',
+    rank: 3,
+    openCommand: '\\biggl',
+    closeCommand: '\\biggr',
+    kind: 'manual',
+  },
+  {
+    name: 'Bigg',
+    rank: 4,
+    openCommand: '\\Biggl',
+    closeCommand: '\\Biggr',
+    kind: 'manual',
+  },
+];
+
+interface CommandSpec extends SizeSpec {
+  readonly command: string;
+  readonly tokenKind: TokenKind;
+}
+
+// Longest first prevents `\Biggl` from being considered as `\Bigl`.
+const COMMAND_SPECS: readonly CommandSpec[] = SIZE_SPECS.flatMap((spec) => [
+  { ...spec, command: spec.openCommand, tokenKind: 'open' as const },
+  { ...spec, command: spec.closeCommand, tokenKind: 'close' as const },
+]).sort((left, right) => right.command.length - left.command.length);
+
+const SUGGESTION_BY_RANK = new Map(
+  SIZE_SPECS.filter((spec) => spec.rank >= 2).map((spec) => [spec.rank, spec]),
+);
+
+function delimiterAt(
+  latex: string,
+  offset: number,
+  kind: TokenKind,
+): { delimiter: string; end: number } | undefined {
+  const candidates =
+    kind === 'open'
+      ? (['\\{', '(', '['] as const)
+      : (['\\}', ')', ']'] as const);
+  for (const delimiter of candidates) {
+    if (latex.startsWith(delimiter, offset)) {
+      return { delimiter, end: offset + delimiter.length };
+    }
+  }
+  return undefined;
+}
+
+function tokenAt(latex: string, offset: number): DelimiterToken | undefined {
+  if (latex[offset] !== '\\') return undefined;
+  for (const spec of COMMAND_SPECS) {
+    if (!latex.startsWith(spec.command, offset)) continue;
+    const afterCommand = offset + spec.command.length;
+    // A longer control word such as `\leftarrow` is not `\left`.
+    if (/[A-Za-z]/.test(latex[afterCommand] ?? '')) continue;
+    let delimiterOffset = afterCommand;
+    while (/\s/.test(latex[delimiterOffset] ?? '')) delimiterOffset += 1;
+    const delimiter = delimiterAt(latex, delimiterOffset, spec.tokenKind);
+    if (!delimiter) continue;
+    return {
+      kind: spec.tokenKind,
+      pairKind: spec.kind,
+      rank: spec.rank,
+      size: spec.name,
+      delimiter: delimiter.delimiter,
+      offset,
+      end: delimiter.end,
+    };
+  }
+  return undefined;
+}
+
+function pairMatches(open: DelimiterToken, close: DelimiterToken): boolean {
+  return (
+    open.kind === 'open' &&
+    close.kind === 'close' &&
+    open.pairKind === close.pairKind &&
+    open.rank === close.rank
+  );
+}
+
+function isEscaped(latex: string, offset: number): boolean {
+  let slashes = 0;
+  for (let index = offset - 1; index >= 0 && latex[index] === '\\'; index -= 1) {
+    slashes += 1;
+  }
+  return slashes % 2 === 1;
+}
+
+/**
+ * Build a real nesting tree using an explicit stack. Malformed input is left
+ * to KaTeX's syntax diagnostics; this linter emits no potentially misleading
+ * size advice for a source whose pairs cannot be matched reliably.
+ */
+function parseDelimiterPairs(latex: string): DelimiterPair[] | undefined {
+  const roots: DelimiterPair[] = [];
+  const stack: DelimiterPair[] = [];
+
+  for (let offset = 0; offset < latex.length; offset += 1) {
+    if (latex[offset] === '%' && !isEscaped(latex, offset)) {
+      const newline = latex.indexOf('\n', offset + 1);
+      if (newline === -1) break;
+      offset = newline;
+      continue;
+    }
+    const token = isEscaped(latex, offset) ? undefined : tokenAt(latex, offset);
+    if (!token) continue;
+    offset = token.end - 1;
+
+    if (token.kind === 'open') {
+      const pair: DelimiterPair = { open: token, children: [] };
+      const parent = stack[stack.length - 1];
+      if (parent) parent.children.push(pair);
+      else roots.push(pair);
+      stack.push(pair);
+      continue;
+    }
+
+    const pair = stack[stack.length - 1];
+    if (!pair || !pairMatches(pair.open, token)) return undefined;
+    pair.close = token;
+    stack.pop();
+  }
+
+  return stack.length === 0 ? roots : undefined;
+}
+
+function lineAndColumn(
+  source: string,
+  offset: number,
+): { line: number; column: number } {
+  const before = source.slice(0, offset);
+  const lastNewline = before.lastIndexOf('\n');
+  return {
+    line: before.split('\n').length,
+    column: offset - lastNewline,
+  };
+}
+
+function sizeName(rank: number): DelimiterSizeName {
+  return SUGGESTION_BY_RANK.get(rank)?.name ?? 'Bigg';
+}
+
+function suggestionFor(
+  pair: DelimiterPair,
+  requiredRank: number,
+): DelimiterSizeSuggestion | undefined {
+  const close = pair.close;
+  const spec = SUGGESTION_BY_RANK.get(requiredRank);
+  if (!close || !spec || spec.name === 'automatic' || spec.name === 'big') {
+    return undefined;
+  }
+  return {
+    size: spec.name,
+    open: `${spec.openCommand}${pair.open.delimiter}`,
+    close: `${spec.closeCommand}${close.delimiter}`,
+    latex: `${spec.openCommand}${pair.open.delimiter} ... ${spec.closeCommand}${close.delimiter}`,
+  };
+}
+
+/**
+ * Warn when a scalable outer pair is not at least one manual size level above
+ * everything nested inside it. `\left` and `\big` form the baseline level;
+ * progressively larger levels are `\Big`, `\bigg`, and `\Bigg`.
+ *
+ * Only `()`, `[]`, and `\{\}` are parsed. Bare delimiters are intentionally
+ * ignored: N15 owns that separate error, while ordinary semantic notation
+ * such as `f(x)` and `\mathbb{E}[X]` must not trigger this size-only linter.
+ */
+export function lintDelimiterSizes(latex: string): DelimiterSizeDiagnostic[] {
+  const roots = parseDelimiterPairs(latex);
+  if (!roots) return [];
+  const diagnostics: DelimiterSizeDiagnostic[] = [];
+
+  const assess = (pair: DelimiterPair): number => {
+    let largestNestedRequirement = 0;
+    let representativeNestedSize: DelimiterSizeName = 'automatic';
+    for (const child of pair.children) {
+      const childRequired = assess(child);
+      if (childRequired > largestNestedRequirement) {
+        largestNestedRequirement = childRequired;
+        representativeNestedSize = sizeName(childRequired);
+      }
+    }
+
+    const requiredRank =
+      largestNestedRequirement === 0
+        ? pair.open.rank
+        : largestNestedRequirement + 1;
+    pair.requiredRank = Math.max(pair.open.rank, requiredRank);
+    if (largestNestedRequirement > 0 && pair.open.rank < requiredRank) {
+      const location = lineAndColumn(latex, pair.open.offset);
+      const suggestion = suggestionFor(pair, requiredRank);
+      diagnostics.push({
+        code: DELIMITER_SIZE_DIAGNOSTIC_CODE,
+        severity: 'warning',
+        offset: pair.open.offset,
+        ...location,
+        outerSize: pair.open.size,
+        nestedSize: representativeNestedSize,
+        ...(suggestion ? { suggestion } : {}),
+        message: suggestion
+          ? `Outer delimiters are not larger than their nested pair. Use ${suggestion.latex}; preserve the original opening and closing delimiter shapes (rule N17).`
+          : `Outer delimiters are not larger than their nested pair, and no larger standard manual delimiter size remains. Preserve the original opening and closing shapes and restructure the expression if necessary (rule N17).`,
+      });
+    }
+    return pair.requiredRank;
+  };
+
+  for (const root of roots) assess(root);
+  return diagnostics.sort((left, right) => left.offset - right.offset);
+}

package/src/reference/diagrams-validate.ts

@@ -15,7 +15,7 @@ export type DiagramDiagnosticCode =
 
 export interface DiagramDiagnostic {
   readonly code: DiagramDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;

package/src/reference/equations-validate.ts

@@ -4,7 +4,7 @@
  * - `eq-duplicate-key` (Tier 1, error): an `eq:` key is unique per lesson.
  * - `eq-ref-resolves` (Tier 1, error): every `[[eq-key]]` / `[[slug#eq-key]]`
  *   points at a display equation that carries `\label{eq:key}`.
- * - `eq-key-unused` (Tier 3, warning): a labelled equation never referenced.
+ * - `eq-key-unused` (info): a labelled equation is never referenced.
  *
  * The remark pass enforces the same rules on the render path; this gives the
  * fast `pnpm validate:content` the same coverage and feeds the manifest.
@@ -33,7 +33,7 @@ export type EquationDiagnosticCode =
 
 export interface EquationDiagnostic {
   readonly code: EquationDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;
@@ -154,7 +154,7 @@ export function validateEquations(
     if (referenced.has(`${label.slug}#${label.key}`)) continue;
     diagnostics.push({
       code: 'eq-key-unused',
-      severity: 'warning',
+      severity: 'info',
       message: `${label.lessonId} labels eq:${label.key} (${label.number}) but nothing references it with [[eq-${label.key}]]`,
       file: label.slug,
       lessonId: label.lessonId,

package/src/reference/figures-validate.ts

@@ -15,7 +15,7 @@ export type FigureDiagnosticCode =
 
 export interface FigureDiagnostic {
   readonly code: FigureDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;

package/src/reference/gate-math.ts

@@ -7,10 +7,12 @@
  * a single diagnostic shape; `astro build` re-runs the same resolver on the
  * render path as a backstop.
  *
- * Every failure names `file:line: "token"` and the fix.
+ * Every finding names its source and the fix. N17's size-only findings are
+ * warnings and include a column when the math came from lesson/assessment text.
  */
 import { resolveMathGlyphs, GlyphResolutionError } from './math-glyphs.mjs';
 import { stripEquationLabels } from './equations.mjs';
+import { lintDelimiterSizes } from './delimiter-size';
 import { formulaGlyphScope, unknownFormulaScopeKeys } from './gloss';
 import type { GlyphScopeEntry } from './gloss';
 import type {
@@ -45,8 +47,10 @@ export interface MathGateDiagnostic {
    * than adding a second array the CLI has to know about.
    */
   readonly severity: 'error' | 'warning';
+  readonly code?: string;
   readonly file: string;
   readonly line?: number;
+  readonly column?: number;
   readonly token?: string;
   readonly message: string;
 }
@@ -92,6 +96,7 @@ function lineOf(text: string, index: number): number {
 interface MathSpan {
   readonly latex: string;
   readonly line: number;
+  readonly column: number;
 }
 
 function mathSpans(body: string): MathSpan[] {
@@ -101,10 +106,14 @@ function mathSpans(body: string): MathSpan[] {
     pattern.lastIndex = 0;
     let match: RegExpExecArray | null;
     while ((match = pattern.exec(searchable))) {
+      const latex = match[1] ?? '';
+      const latexOffset = match.index + match[0].indexOf(latex);
+      const before = body.slice(0, latexOffset);
+      const lastNewline = before.lastIndexOf('\n');
       spans.push({
-        // D7: `\label{eq:…}` is an identity marker, not math KaTeX parses.
-        latex: stripEquationLabels(match[1] ?? ''),
-        line: lineOf(body, match.index),
+        latex,
+        line: lineOf(body, latexOffset),
+        column: latexOffset - lastNewline,
       });
     }
   }
@@ -150,12 +159,34 @@ function resolveInto(
   context: MathGateDiagnostic['context'],
   file: string,
   line: number | undefined,
+  column: number | undefined,
   fix: string,
   out: MathGateDiagnostic[],
 ): void {
+  for (const diagnostic of lintDelimiterSizes(latex)) {
+    const locatedLine =
+      line === undefined ? undefined : line + diagnostic.line - 1;
+    const locatedColumn =
+      column === undefined
+        ? undefined
+        : diagnostic.line === 1
+          ? column + diagnostic.column - 1
+          : diagnostic.column;
+    out.push({
+      context,
+      code: diagnostic.code,
+      severity: 'warning',
+      file,
+      ...(locatedLine === undefined ? {} : { line: locatedLine }),
+      ...(locatedColumn === undefined ? {} : { column: locatedColumn }),
+      message: diagnostic.message,
+    });
+  }
+
   let result;
   try {
-    result = resolveMathGlyphs(latex, [...scope]);
+    // D7: `\label{eq:…}` is an identity marker, not math KaTeX parses.
+    result = resolveMathGlyphs(stripEquationLabels(latex), [...scope]);
   } catch (error) {
     out.push({
       context,
@@ -283,6 +314,7 @@ export function gateContentMath(input: {
         'body',
         file,
         span.line,
+        span.column,
         BODY_FIX,
         diagnostics,
       );
@@ -305,6 +337,7 @@ export function gateContentMath(input: {
         'formula',
         file,
         undefined,
+        undefined,
         FORMULA_FIX,
         diagnostics,
       );
@@ -330,6 +363,7 @@ export function gateContentMath(input: {
       'formula',
       definition.source.file,
       undefined,
+      undefined,
       SHARED_FORMULA_FIX,
       diagnostics,
     );
@@ -358,7 +392,8 @@ export function gateContentMath(input: {
               scope,
               'assessment',
               `${assessmentId} (${item.id ?? '?'})`,
-              undefined,
+              span.line,
+              span.column,
               ASSESSMENT_FIX,
               diagnostics,
             );

package/src/reference/keyed-float-validate.ts

@@ -7,7 +7,7 @@
  * - `<prefix>-duplicate-key` (error): an `id` is unique per lesson.
  * - `<prefix>-ref-resolves` (error): every `[[<prefix>-key]]` /
  *   `[[slug#<prefix>-key]]` points at the matching keyed float with that `id`.
- * - `<prefix>-key-unused` (warning): a keyed float never referenced.
+ * - `<prefix>-key-unused` (info): a keyed float is never referenced.
  *
  * `tables-validate.ts`, `figures-validate.ts`, and `diagrams-validate.ts` are
  * thin wrappers over this so callers import a kind-specific validator with
@@ -48,7 +48,7 @@ export interface KeyedFloatRefRecord {
 
 export interface KeyedFloatDiagnostic {
   readonly code: string;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;
@@ -190,7 +190,7 @@ export function validateKeyedFloats(
     if (referenced.has(`${label.slug}#${label.key}`)) continue;
     diagnostics.push({
       code: `${prefix}-key-unused`,
-      severity: 'warning',
+      severity: 'info',
       message: `${label.lessonId} has a ${noun} id="${label.key}" (${label.number}) but nothing references it with [[${prefix}-${label.key}]]`,
       file: label.slug,
       lessonId: label.lessonId,

package/src/reference/references.ts

@@ -78,5 +78,6 @@ export function compareDiagnostics(
 }
 
 function severityRank(severity: NotationDiagnostic['severity']): number {
-  return severity === 'error' ? 0 : 1;
+  if (severity === 'error') return 0;
+  return severity === 'warning' ? 1 : 2;
 }

package/src/reference/registry.ts

@@ -214,7 +214,7 @@ export function buildNotationRegistry(
     if (!reachableDefinitions.has(candidate.id)) {
       diagnostics.push({
         code: 'unused-definition',
-        severity: 'warning',
+        severity: 'info',
         message: `${candidate.id} is not reachable from any lesson reference`,
         key: candidate.input.key,
         lessonId:

package/src/reference/rehype-base-links.mjs

@@ -0,0 +1,40 @@
+/**
+ * Prefixes root-relative `<a href="/...">` links in rendered lesson content
+ * with the course's Astro `base` path.
+ *
+ * A course deployed under a subpath (any GitHub Pages *project* site, e.g.
+ * `base: '/my-course'`) gets that prefix applied automatically to Starlight's
+ * own generated navigation — sidebar, pagination, breadcrumbs — because those
+ * are rendered by Starlight's own `.astro` components, which call its
+ * internal `pathWithBase()` helper. They are **not** applied to anything
+ * produced by the Markdown/MDX → rehype pipeline: a lesson's own prose links
+ * (`[text](/other-lesson/)`), `remark-notation.mjs`'s equation cross-
+ * references, and `remark-citation.mjs`'s citation links are all root-
+ * relative absolute paths written or generated without the base in mind, so
+ * without this plugin every one of them 404s on a subpath deployment. A
+ * lesson's Starlight frontmatter (e.g. `hero.actions[].link`) is untouched
+ * either way — that YAML never enters this pipeline — so write those as
+ * paths relative to the current page instead.
+ *
+ * A no-op when the course has no base (`base` omitted or `'/'`, e.g. local
+ * dev or a GitHub *user/org* Pages site), so a course can wire this in
+ * unconditionally and it only does anything on the deployments that need it.
+ */
+export default function rehypeBaseLinks(base) {
+  const prefix = base && base !== '/' ? base.replace(/\/+$/, '') : '';
+
+  return function transform(tree) {
+    if (!prefix) return;
+    visit(tree);
+  };
+
+  function visit(node) {
+    if (node.type === 'element' && node.tagName === 'a') {
+      const href = node.properties?.href;
+      if (typeof href === 'string' && href.startsWith('/') && !href.startsWith('//')) {
+        node.properties.href = prefix + href;
+      }
+    }
+    if (Array.isArray(node.children)) node.children.forEach(visit);
+  }
+}

package/src/reference/remark-abbreviations.mjs

@@ -5,12 +5,15 @@
  * requires every abbreviation-shaped word in prose to either be universal or
  * carry a `content/abbreviations/*.md` entry, so the literal written form
  * (`abbr`, or one of its `aliases`) is itself the trigger. This plugin scans
- * ordinary prose for that literal text and wraps the **first** occurrence per
- * document in a real link (`/glossary/#abbr-<key>`, so it still navigates
- * with no JS) carrying the `data-abbr-key` an island script reads to render a
- * hover/click card, exactly the way `remarkCitation` wraps `[@id]` markers.
- * Later occurrences of the same term on the same page stay plain text, so a
- * common short word isn't turned into a link everywhere it appears.
+ * ordinary prose for that literal text and wraps **every** occurrence in a
+ * real link (`/glossary/#abbr-<key>`, so it still navigates with no JS)
+ * carrying the `data-abbr-key` an island script reads to render a hover/click
+ * card, exactly the way `remarkCitation` wraps `[@id]` markers. A reader who
+ * deep-links into a mid-page heading — the sidebar TOC, a heading anchor, an
+ * external link — sees the same hoverable cue no matter which occurrence they
+ * land on first, rather than only the earliest one in document order.
+ * `AbbreviationLayer.astro` already resolves every marker independently by
+ * `data-abbr-key`, so wrapping every occurrence needs no island-side change.
  *
  * Matches only ever come from the known table by construction, so unlike
  * citation's `[@id]` there is no "unknown id" failure path here.
@@ -118,10 +121,6 @@ export default function remarkAbbreviations(options = {}) {
     const { regex, keyByMatch } = buildMatcher(suppliedAbbreviations);
     if (!regex) return;
 
-    // Fresh per file, same lifetime as citation's own `pairs` Map: only the
-    // first occurrence of a given key on this page gets wrapped.
-    const usedKeys = new Set();
-
     const replaceText = (value) => {
       regex.lastIndex = 0;
       const output = [];
@@ -131,13 +130,12 @@ export default function remarkAbbreviations(options = {}) {
 
       while ((match = regex.exec(value))) {
         const key = keyByMatch.get(match[0]);
-        if (!key || usedKeys.has(key)) continue;
+        if (!key) continue;
 
         if (match.index > cursor) {
           output.push({ type: 'text', value: value.slice(cursor, match.index) });
         }
         output.push(termNode(key, match[0], base));
-        usedKeys.add(key);
         changed = true;
         cursor = match.index + match[0].length;
       }

package/src/reference/render-lab-math.ts

@@ -1,5 +1,5 @@
 import katex from 'katex';
-import { resolveMathGlyphs } from './math-glyphs.mjs';
+import { resolveMathGlyphs, stripNotationMarkers } from './math-glyphs.mjs';
 import { createNotationKatexOptions } from './katex-options.mjs';
 
 export interface LabMathScopeDefinition {
@@ -14,6 +14,26 @@ export interface RenderedLabMath {
   readonly slots: readonly string[];
   /** Notation keys the template resolved to, for diagnostics. */
   readonly keys: readonly string[];
+  /**
+   * Plain, copyable LaTeX — every explained glyph resolved to its bare
+   * symbol, every `\slot{name}{…}` replaced by `slotPlaceholder(name)` — so
+   * the island can substitute each slot's *current* live value in and keep
+   * `[data-notation-formula]`'s `data-latex` accurate as the reader drags a
+   * control, the same "click the equation to copy it" gesture a static
+   * lesson or glossary equation gets (`NotationLayer.astro`).
+   */
+  readonly plainLatexTemplate: string;
+}
+
+/**
+ * A slot's placeholder inside `plainLatexTemplate` — distinct from the
+ * numeric sentinel `sentinelFor` below uses internally (that one only has to
+ * survive a single notation-binding pass at build time; this one is the
+ * stable, name-keyed token an island substitutes with a live value at
+ * runtime, so it's exported for that purpose).
+ */
+export function slotPlaceholder(name: string): string {
+  return `⟦${name}⟧`;
 }
 
 interface BindResult {
@@ -72,6 +92,7 @@ export function renderLabMath(
   }
 
   let bound = result.latex;
+  let copyBound = result.latex;
   slots.forEach(({ name, fallback }, index) => {
     const sentinel = sentinelFor(index);
     if (!bound.includes(sentinel)) {
@@ -84,6 +105,7 @@ export function renderLabMath(
       sentinel,
       `\\htmlData{lab-slot=${name}}{${fallback}}`,
     );
+    copyBound = copyBound.replace(sentinel, slotPlaceholder(name));
   });
 
   const html = katex.renderToString(
@@ -95,5 +117,6 @@ export function renderLabMath(
     html,
     slots: slots.map(({ name }) => name),
     keys: [...new Set(result.bindings.map(({ key }) => key))],
+    plainLatexTemplate: stripNotationMarkers(copyBound),
   };
 }

package/src/reference/tables-validate.ts

@@ -15,7 +15,7 @@ export type TableDiagnosticCode =
 
 export interface TableDiagnostic {
   readonly code: TableDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: 'error' | 'warning' | 'info';
   readonly message: string;
   readonly file?: string;
   readonly lessonId?: string;

package/src/reference/types.ts

@@ -127,7 +127,7 @@ export type NotationDiagnosticCode =
   | 'alignment-review-state'
   | 'gloss-collides-with-card';
 
-export type DiagnosticSeverity = 'error' | 'warning';
+export type DiagnosticSeverity = 'error' | 'warning' | 'info';
 
 export interface NotationDiagnostic {
   readonly code: NotationDiagnosticCode;