explico 0.11.1 → 0.13.0

package/dist/reference/gate-indices.js

@@ -0,0 +1,299 @@
+import { stripEquationLabels } from "./equations.mjs";
+import { resolveMathGlyphs, stripNotationMarkers } from "./math-glyphs.mjs";
+import {
+  equationLinkFor,
+  mathSpans,
+  pageScope,
+  suspendedOperators
+} from "./gate-math.js";
+import { formulaGlyphScope } from "./gloss.js";
+import { indexOfEntry } from "./math-glyphs.mjs";
+const INDEX_FIX = {
+  body: (token, subscript) => `Give the indexed symbol its own entry (latex: ${token}), a family entry whose index runs (latex: x_k), or an index entry for the subscript (latex: "{}_${subscript}", label and meaning), introduced with [[key]] or in notation.local`,
+  assessment: (token, subscript) => `Give the indexed symbol its own entry (latex: ${token}), a family entry whose index runs (latex: x_k), or an index entry for the subscript (latex: "{}_${subscript}"), introduced in the lesson's prose with [[key]] or in its notation.local`,
+  formula: (token, subscript) => `In a formula, wrap the symbol in \\explain{key}{${token}} with an entry for the indexed symbol, declare it under glosses: (latex: ${token}), or wrap the subscript in an index entry's key (\\explain{key}{${subscript}})`
+};
+const DISPLAY_OPEN = /\$\$\s*$/;
+const RANGE_RELATION = /(?:=|<|>|\\(?:in|le|leq|ge|geq|lt|gt|dots|ldots|cdots|to|subseteq|subset)(?![A-Za-z]))/;
+function quadClauses(mathLine) {
+  return mathLine.split(/\\quad(?![A-Za-z])/).slice(1).map((clause) => stripNotationMarkers(clause));
+}
+function statesRange(clause, letter) {
+  const named = new RegExp(`(?<![A-Za-z\\\\])${letter}(?![A-Za-z])`);
+  return named.test(clause) && RANGE_RELATION.test(clause);
+}
+function mathLineAt(latex, offset) {
+  const before = latex.slice(0, offset).split(/\\\\/);
+  const after = latex.slice(offset).split(/\\\\/);
+  return `${before[before.length - 1] ?? ""}${after[0] ?? ""}`;
+}
+function message(lessonId, code, details, place = "body") {
+  switch (code) {
+    case "index-explained": {
+      const index = details.index ?? "";
+      const subscript = index.length === 1 ? index : `{${index}}`;
+      const what = details.base === "false" ? `has no card, and neither does its base (${details.parts})` : `has a subscript no card explains (${details.parts})`;
+      return `${lessonId}: ${JSON.stringify(details.token)} ${what}. ${INDEX_FIX[place](details.token ?? "", subscript)}; a letter in a subscript is an index, so a base-library i, e or d there needs a card (rule N23).`;
+    }
+    case "index-swallowed":
+      return `${lessonId}: \\explain{${details.key}}{${details.token}} wraps an indexed symbol in ${details.key}, whose latex (${details.notation}) has no index, so its card cannot explain ${JSON.stringify(details.index)}. Drop the wrap and give the subscript an index entry (latex: "{}_${details.index}"), or wrap it in an entry for the indexed symbol (rule N23).`;
+    case "index-range":
+      return `${lessonId}: the running index ${details.letter} (first in ${JSON.stringify(details.token)}) has no stated set. Give ${details.where} a range (range: "1, \\\\dots, n"), state it after a \\quad on the first display line that uses it (\\quad ${details.letter} = 1, \\dots, n), or mark the card fixedIndex: true if ${details.letter} is a label there, not a running index (rule N23).`;
+    case "derived-key-taken":
+      return `${lessonId}: ${JSON.stringify(details.token)} composes the derived card ${details.key}, but an authored entry has that key. Rename the entry: a key of the form <symbol>.sub.<index> is the build's (rule N23).`;
+  }
+}
+function gateIndices(lessons, entries, extras = {}) {
+  const diagnostics = [];
+  const derivedByLesson = /* @__PURE__ */ new Map();
+  for (const lesson of lessons) {
+    const file = lesson.source.file;
+    const bodyOffset = (lesson.bodyLine ?? 1) - 1;
+    const scope = pageScope(lesson, entries);
+    const local = new Map(
+      lesson.localDefinitions.map((definition) => [definition.key, definition])
+    );
+    const factsOf = (key) => key === null ? void 0 : local.get(key) ?? entries.get(key);
+    const suspended = suspendedOperators(lesson);
+    const derived = /* @__PURE__ */ new Map();
+    const reported = /* @__PURE__ */ new Set();
+    const occurrences = [];
+    const spans = mathSpans(lesson.body).sort((left, right) => left.offset - right.offset);
+    for (const span of spans) {
+      const latex = stripEquationLabels(span.latex);
+      let result;
+      try {
+        result = resolveMathGlyphs(latex, scope, { suspended, derive: true });
+      } catch {
+        continue;
+      }
+      const line = span.line + bodyOffset;
+      const equation = equationLinkFor(lesson.lessonId, span.latex);
+      const at = {
+        context: "body",
+        severity: "error",
+        file,
+        line,
+        ...equation === void 0 ? {} : { equation }
+      };
+      const display = DISPLAY_OPEN.test(lesson.body.slice(0, span.offset));
+      for (const use of result.derived) {
+        if (!derived.has(use.key)) derived.set(use.key, use);
+        if (factsOf(use.key) !== void 0 && !reported.has(`taken:${use.key}`)) {
+          reported.add(`taken:${use.key}`);
+          diagnostics.push({
+            ...at,
+            code: "derived-key-taken",
+            token: use.key,
+            message: message(lesson.lessonId, "derived-key-taken", {
+              key: use.key,
+              token: use.key
+            })
+          });
+        }
+      }
+      for (const item of result.indices) {
+        pushFindings(item, at, lesson.lessonId, "body", factsOf, reported, diagnostics);
+        for (const running of item.running) {
+          if (running.key === null && running.cover === null) continue;
+          occurrences.push({
+            letter: running.letter,
+            line,
+            display,
+            mathLine: mathLineAt(latex, running.start),
+            token: item.token,
+            ownKey: running.key,
+            coverKey: running.cover
+          });
+        }
+      }
+    }
+    const byLetter = /* @__PURE__ */ new Map();
+    for (const occurrence of occurrences) {
+      const list = byLetter.get(occurrence.letter) ?? [];
+      list.push(occurrence);
+      byLetter.set(occurrence.letter, list);
+    }
+    for (const [letter, list] of byLetter) {
+      const declared = list.some(
+        (occurrence) => [occurrence.ownKey, occurrence.coverKey].some((key) => {
+          const facts = factsOf(key);
+          return facts?.range !== void 0 || facts?.fixedIndex === true;
+        })
+      );
+      if (declared) continue;
+      const firstDisplay = list.find((occurrence) => occurrence.display);
+      if (firstDisplay && quadClauses(firstDisplay.mathLine).some((clause) => statesRange(clause, letter))) {
+        continue;
+      }
+      const [first] = list;
+      if (!first) continue;
+      const card = first.ownKey ?? first.coverKey;
+      diagnostics.push({
+        context: "body",
+        severity: "error",
+        code: "index-range",
+        file,
+        line: first.line,
+        token: letter,
+        message: message(lesson.lessonId, "index-range", {
+          letter,
+          token: first.token,
+          where: card === null ? `the card of ${letter}` : `the card ${card}`
+        })
+      });
+    }
+    if (derived.size > 0) derivedByLesson.set(lesson.lessonId, [...derived.values()]);
+    for (const definition of lesson.localDefinitions) {
+      if (!definition.formula || indexOfEntry(definition.notation) !== void 0) continue;
+      checkFormula(
+        definition.formula,
+        dedupeRows([...scope, ...definition.glosses]),
+        `${lesson.lessonId}: notation.local ${definition.key} formula`,
+        file,
+        factsOf,
+        reported,
+        diagnostics
+      );
+    }
+  }
+  const cards = new Map(entries);
+  for (const entry of entries.values()) {
+    if (!entry.formula || indexOfEntry(entry.notation) !== void 0) continue;
+    checkFormula(
+      entry.formula,
+      formulaGlyphScope({
+        key: entry.key,
+        notation: entry.notation,
+        formula: entry.formula,
+        glosses: entry.glosses ?? [],
+        cardsByKey: cards
+      }),
+      `notation ${entry.key} formula`,
+      entry.source?.file ?? `content/notation/${entry.key}.md`,
+      (key) => key === null ? void 0 : entries.get(key),
+      /* @__PURE__ */ new Set(),
+      diagnostics
+    );
+  }
+  const lessonById = new Map(lessons.map((lesson) => [lesson.lessonId, lesson]));
+  const assessmentById = new Map(
+    (extras.assessments ?? []).map((assessment) => [assessment.id, assessment])
+  );
+  for (const link of extras.lessonAssessments ?? []) {
+    const lesson = lessonById.get(link.lessonId);
+    if (!lesson) continue;
+    const scope = pageScope(lesson, entries);
+    const local = new Map(
+      lesson.localDefinitions.map((definition) => [definition.key, definition])
+    );
+    const factsOf = (key) => key === null ? void 0 : local.get(key) ?? entries.get(key);
+    for (const assessmentId of link.assessmentIds) {
+      const assessment = assessmentById.get(assessmentId);
+      const reported = /* @__PURE__ */ new Set();
+      for (const item of assessment?.items ?? []) {
+        for (const field of [
+          item.prompt,
+          item.explanation,
+          ...(item.options ?? []).map((option) => option.label)
+        ]) {
+          if (typeof field !== "string") continue;
+          for (const span of mathSpans(field)) {
+            let result;
+            try {
+              result = resolveMathGlyphs(span.latex, scope, { derive: true });
+            } catch {
+              continue;
+            }
+            const at = {
+              context: "assessment",
+              severity: "error",
+              file: `${assessmentId} (${item.id ?? "?"})`,
+              line: span.line
+            };
+            for (const indexed of result.indices) {
+              pushFindings(
+                indexed,
+                at,
+                `${link.lessonId}: assessment ${assessmentId}`,
+                "assessment",
+                factsOf,
+                reported,
+                diagnostics
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  return { diagnostics, derivedByLesson };
+}
+function pushFindings(item, at, owner, place, factsOf, reported, diagnostics) {
+  const token = item.token.replace(/\s+/g, "");
+  if (item.how === "swallowed" && !reported.has(`swallowed:${token}`)) {
+    reported.add(`swallowed:${token}`);
+    diagnostics.push({
+      ...at,
+      code: "index-swallowed",
+      token: item.token,
+      message: message(owner, "index-swallowed", {
+        key: item.key ?? "",
+        token: item.token,
+        notation: factsOf(item.key)?.notation ?? "",
+        index: item.index
+      })
+    });
+  } else if (item.how === "composed" && !item.explained && !reported.has(`explained:${token}`)) {
+    reported.add(`explained:${token}`);
+    diagnostics.push({
+      ...at,
+      code: "index-explained",
+      token: item.token,
+      message: message(
+        owner,
+        "index-explained",
+        {
+          token: item.token,
+          index: item.index.replace(/^\{([\s\S]*)\}$/, "$1"),
+          parts: item.unexplained.map((part) => JSON.stringify(part)).join(", "),
+          base: String(item.baseExplained)
+        },
+        place
+      )
+    });
+  }
+}
+function checkFormula(formula, scope, owner, file, factsOf, reported, diagnostics) {
+  let result;
+  try {
+    result = resolveMathGlyphs(formula, [...scope]);
+  } catch {
+    return;
+  }
+  const at = { context: "formula", severity: "error", file };
+  for (const item of result.indices) {
+    pushFindings(item, at, owner, "formula", factsOf, reported, diagnostics);
+  }
+}
+function dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => !seen.has(row.key) && Boolean(seen.add(row.key)));
+}
+function indexFindings(indices) {
+  return indices.flatMap((item) => {
+    if (item.how === "swallowed") {
+      return [
+        `${item.token}: \\explain{${item.key ?? ""}}{\u2026} names an entry whose latex has no index, so its card cannot explain ${JSON.stringify(item.index)}; give the subscript an index entry ({}_${item.index.length === 1 ? item.index : `{${item.index}}`}) and drop the wrap, or name an entry for the indexed symbol`
+      ];
+    }
+    if (item.how !== "composed" || item.explained) return [];
+    return [
+      `${item.token}: no card explains ${item.unexplained.map((part) => JSON.stringify(part)).join(", ")}; give the indexed symbol its own entry, a family entry (x_k), or an index entry for the subscript ({}_0) in the page's notation`
+    ];
+  });
+}
+export {
+  gateIndices,
+  indexFindings
+};

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

@@ -58,6 +58,10 @@ interface AssessmentItemLike {
     readonly id?: string;
     readonly prompt?: string;
     readonly explanation?: string;
+    /** A choice item's options; a label's math renders like the prompt's. */
+    readonly options?: readonly {
+        readonly label?: string;
+    }[];
 }
 interface AssessmentLike {
     readonly id: string;
@@ -74,12 +78,27 @@ interface MathSpan {
     /** Index of `latex` in the text it was cut from. */
     readonly offset: number;
 }
-/** Every `$$…$$` then `$…$` span in `body`, outside code, with its position. */
+/**
+ * Every `$$…$$` then `$…$` span in `body`, outside code and quoted JSX props
+ * (plain text that never reaches KaTeX; invariant `prop-text`), with its
+ * position.
+ */
 declare function mathSpans(body: string): MathSpan[];
+/**
+ * One row of a page's glyph table. `fixedIndex` (rule N23) tells the
+ * resolver that an entry's index is a fixed label, so it is no family.
+ */
 type ScopeEntry = {
     key: string;
     notation: string;
+    fixedIndex?: true;
 };
+/** A definition as a glyph-table row, `fixedIndex` kept. */
+declare function scopeEntry(definition: {
+    readonly key: string;
+    readonly notation: string;
+    readonly fixedIndex?: true;
+}): ScopeEntry;
 /**
  * A lesson's flat glyph table: its own `notation.local` entries plus every
  * shared card it introduces with `[[key]]` / `\explain{key}`. Exported so a
@@ -96,6 +115,17 @@ declare function pageScope(lesson: NotationLessonInput, sharedByKey: ReadonlyMap
 declare function equationLinkFor(lessonId: string, latex: string): EquationLink | undefined;
 /** Decorations a lesson suspends (`notation.suspend`, rule N22), by name. */
 declare function suspendedOperators(lesson: NotationLessonInput): string[];
+/**
+ * The `$…$` pairs remark-math reads as math that hold an amount of money
+ * instead: `$5 to $6`, `$5–$10`, `$5, and $x`. remark-math pairs any two
+ * single `$` on a line, left to right; `mathSpans` follows Pandoc (no space
+ * before a closing `$`, no digit after it) and skips them, so such a pair was
+ * neither checked as math nor shown as money — the page printed "5 to 6", or
+ * the build failed on the letters of "and". A pair is money when its content
+ * starts with a digit and either ends in a space or runs straight into a
+ * digit after the closing `$`.
+ */
+declare function currencyDollars(body: string): MathSpan[];
 /**
  * Resolve every rendered-math context against the page glyph table. Returns one
  * diagnostic per unresolved token; an empty array means the gate passed.
@@ -106,4 +136,4 @@ declare function gateContentMath(input: {
     readonly lessonAssessments: readonly LessonAssessmentLink[];
 }): MathGateDiagnostic[];
 
-export { type EquationLink, type MathGateDiagnostic, type MathSpan, type ScopeEntry, equationLinkFor, gateContentMath, mathSpans, pageScope, suspendedOperators };
+export { type AssessmentItemLike, type AssessmentLike, type EquationLink, type LessonAssessmentLink, type MathGateDiagnostic, type MathSpan, type ScopeEntry, currencyDollars, equationLinkFor, gateContentMath, mathSpans, pageScope, scopeEntry, suspendedOperators };

package/dist/reference/gate-math.js

@@ -6,6 +6,7 @@ import {
 } from "./equations.mjs";
 import { lintDelimiterSizes } from "./delimiter-size.js";
 import { formulaGlyphScope, unknownFormulaScopeKeys } from "./gloss.js";
+import { blankPropStrings } from "./gate-prop-text.js";
 const SEVERITY = {
   body: "error",
   formula: "error",
@@ -27,7 +28,7 @@ function lineOf(text, index) {
   return text.slice(0, index).split("\n").length;
 }
 function mathSpans(body) {
-  const searchable = stripCode(body);
+  const searchable = stripCode(blankPropStrings(body));
   const spans = [];
   for (const pattern of [DISPLAY_MATH, INLINE_MATH]) {
     pattern.lastIndex = 0;
@@ -47,11 +48,15 @@ function mathSpans(body) {
   }
   return spans;
 }
-function pageScope(lesson, sharedByKey) {
-  const local = lesson.localDefinitions.map((definition) => ({
+function scopeEntry(definition) {
+  return {
     key: definition.key,
-    notation: definition.notation
-  }));
+    notation: definition.notation,
+    ...definition.fixedIndex ? { fixedIndex: true } : {}
+  };
+}
+function pageScope(lesson, sharedByKey) {
+  const local = lesson.localDefinitions.map(scopeEntry);
   const localKeys = new Set(local.map((entry) => entry.key));
   const referenced = /* @__PURE__ */ new Set();
   for (const pattern of [TERM_KEY, EXPLAIN_KEY]) {
@@ -61,7 +66,7 @@ function pageScope(lesson, sharedByKey) {
   for (const key of referenced) {
     if (localKeys.has(key)) continue;
     const shared = sharedByKey.get(key);
-    if (shared) scope.push({ key: shared.key, notation: shared.notation });
+    if (shared) scope.push(scopeEntry(shared));
   }
   return scope;
 }
@@ -77,7 +82,7 @@ function equationLinkFor(lessonId, latex) {
 function suspendedOperators(lesson) {
   return (lesson.suspended ?? []).map((item) => item.operator);
 }
-function resolveInto(latex, scope, context, file, line, column, fix, out, equation, suspended = []) {
+function resolveInto(latex, scope, context, file, line, column, fix, out, equation, suspended = [], derive = false) {
   const at = equation === void 0 ? {} : { equation };
   for (const diagnostic of lintDelimiterSizes(latex)) {
     const locatedLine = line === void 0 ? void 0 : line + diagnostic.line - 1;
@@ -96,7 +101,8 @@ function resolveInto(latex, scope, context, file, line, column, fix, out, equati
   let result;
   try {
     result = resolveMathGlyphs(stripEquationLabels(latex), [...scope], {
-      suspended
+      suspended,
+      derive
     });
   } catch (error) {
     out.push({
@@ -127,6 +133,7 @@ function resolveInto(latex, scope, context, file, line, column, fix, out, equati
       continue;
     }
     const fontHint = "font" in item && typeof item.font === "string" ? ` ${token} is a different symbol from the plain letter: give it its own entry (latex: ${token}) or wrap it in \\explain{key}{${token}}.` : "";
+    const lenderHint = "lenders" in item && Array.isArray(item.lenders) && item.lenders.length > 0 ? ` ${item.lenders.join(", ")} ${item.lenders.length === 1 ? "has" : "have"} ${token} with a subscript, and an indexed entry explains its own instances only, never a bare ${token} (rule N4). If ${token} is a different object, give it its own entry (latex: ${token}); if it is shorthand for that entry, wrap it in \\explain{${item.lenders[0]}}{${token}}.` : "";
     out.push({
       context,
       code: "unresolved-glyph",
@@ -135,10 +142,34 @@ function resolveInto(latex, scope, context, file, line, column, fix, out, equati
       line,
       token,
       ...at,
-      message: `Unresolved notation ${JSON.stringify(token)} in ${context} math.${fontHint} ${fix}`
+      message: `Unresolved notation ${JSON.stringify(token)} in ${context} math.${fontHint}${lenderHint} ${fix}`
     });
   }
 }
+function currencyDollars(body) {
+  const searchable = stripCode(blankPropStrings(body)).replace(
+    DISPLAY_MATH,
+    (block) => block.replace(/[^\n]/g, " ")
+  );
+  const spans = [];
+  let lineStart = 0;
+  searchable.split("\n").forEach((text, index) => {
+    const dollars = [];
+    for (let at = 0; at < text.length; at += 1) {
+      if (text[at] !== "$" || text[at - 1] === "\\" || text[at - 1] === "$" || text[at + 1] === "$") continue;
+      dollars.push(at);
+    }
+    for (let pair = 0; pair + 1 < dollars.length; pair += 2) {
+      const open = dollars[pair];
+      const close = dollars[pair + 1];
+      const latex = text.slice(open + 1, close);
+      if (!/^\d/.test(latex) || !(/\s$/.test(latex) || /^\d/.test(text.slice(close + 1)))) continue;
+      spans.push({ latex, line: index + 1, column: open + 2, offset: lineStart + open + 1 });
+    }
+    lineStart += text.length + 1;
+  });
+  return spans;
+}
 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();
@@ -215,9 +246,24 @@ function gateContentMath(input) {
         BODY_FIX,
         diagnostics,
         equationLinkFor(lesson.lessonId, span.latex),
-        suspended
+        suspended,
+        // Derived cards (rule N23) are lesson-body math, like the render path.
+        true
       );
     }
+    for (const span of currencyDollars(lesson.body)) {
+      const shown = span.latex.replace(/\s+$/, "");
+      diagnostics.push({
+        context: "body",
+        code: "currency-dollar",
+        severity: SEVERITY.body,
+        file,
+        line: span.line + bodyOffset,
+        column: span.column,
+        token: `$${span.latex}$`,
+        message: `"$${span.latex}$" reads as math: remark-math pairs any two dollars on a line, so the page shows "${shown}" without them. Write a currency dollar as \\$ (\\$5 to \\$6), or the amount in words.`
+      });
+    }
     for (const definition of lesson.localDefinitions) {
       if (!definition.formula) continue;
       resolveInto(
@@ -272,7 +318,11 @@ function gateContentMath(input) {
       const assessment = assessmentById.get(assessmentId);
       if (!assessment?.items) continue;
       for (const item of assessment.items) {
-        for (const field of [item.prompt, item.explanation]) {
+        for (const field of [
+          item.prompt,
+          item.explanation,
+          ...(item.options ?? []).map((option) => option.label)
+        ]) {
           if (typeof field !== "string") continue;
           for (const span of mathSpans(field)) {
             resolveInto(
@@ -283,7 +333,11 @@ function gateContentMath(input) {
               span.line,
               span.column,
               ASSESSMENT_FIX,
-              diagnostics
+              diagnostics,
+              void 0,
+              [],
+              // Page math, rendered with derived cards (rule N23).
+              true
             );
           }
         }
@@ -293,9 +347,11 @@ function gateContentMath(input) {
   return diagnostics;
 }
 export {
+  currencyDollars,
   equationLinkFor,
   gateContentMath,
   mathSpans,
   pageScope,
+  scopeEntry,
   suspendedOperators
 };

package/dist/reference/gate-mdx-expression.d.ts

@@ -0,0 +1,17 @@
+import { MathGateDiagnostic } from './gate-math.js';
+import { NotationLessonInput } from './types.js';
+
+/**
+ * The MDX-expression gate (invariant `prop-text`, with the prop gate). MDX
+ * reads `{…}` in a lesson's text as JavaScript: `The set {a} has one element` renders nothing
+ * and fails the build with "a is not defined", in a compiled chunk, with no
+ * file or line. `validate:content` and `content check` parse no expression, so
+ * the build was the first to notice. This gate finds a brace pair in the prose
+ * (code, math, JSX tags, comments, references and import/export lines blanked;
+ * a directive's attributes, `:::note{icon=""}`, kept out) and says what to
+ * write instead. See docs/authoring/components.md#braces-in-prose.
+ */
+
+declare function gateMdxExpressions(lessons: readonly NotationLessonInput[]): MathGateDiagnostic[];
+
+export { gateMdxExpressions };

package/dist/reference/gate-mdx-expression.js

@@ -0,0 +1,29 @@
+import { lessonLine, proseOnly } from "./gate-prose-notation.js";
+const EXPORT_LINE = /^[ \t]*export\b[^\n]*$/gm;
+const DIRECTIVE = /:{1,3}[A-Za-z][\w-]*(?:\[[^\]\n]*\])?\{[^{}\n]*\}/g;
+function gateMdxExpressions(lessons) {
+  const blank = (match) => match.replace(/[^\n]/g, " ");
+  const diagnostics = [];
+  for (const lesson of lessons) {
+    if (!lesson.body.includes("{")) continue;
+    const prose = proseOnly(lesson.body).replace(EXPORT_LINE, blank).replace(DIRECTIVE, blank);
+    for (const match of prose.matchAll(/\{([^{}\n]*)\}/g)) {
+      const index = match.index ?? 0;
+      if (lesson.body[index - 1] === "\\") continue;
+      const inner = lesson.body.slice(index + 1, index + match[0].length - 1);
+      diagnostics.push({
+        context: "prose",
+        code: "mdx-expression",
+        severity: "error",
+        file: lesson.source.file,
+        line: lessonLine(lesson, index),
+        token: `{${inner}}`,
+        message: `{${inner}} in the prose is a JavaScript expression to MDX, and the build fails on it ("${inner.trim() || "\u2026"} is not defined"). Write \\{${inner}\\} for braces in the text, or $\\{${inner}\\}$ for a set.`
+      });
+    }
+  }
+  return diagnostics;
+}
+export {
+  gateMdxExpressions
+};

package/dist/reference/gate-non-chapter-pages.d.ts

@@ -0,0 +1,39 @@
+import { MathGateDiagnostic } from './gate-math.js';
+import './types.js';
+
+/**
+ * The non-chapter page gate (rule S10). A page that is not a chapter — the
+ * landing page, a part's overview page, any other page outside a part
+ * directory — explains its symbols like a chapter does, but numbers nothing:
+ *
+ * - no numbered block: `<Table>`, `<Figure>`, `<Diagram>`, `<CompactExamples>`,
+ *   `<AssessmentSet>`, and no lab (a component imported from a `labs/` module,
+ *   or any hydrated `client:*` island) — code `non-chapter-float`;
+ * - no `\label{eq:…}` on a display equation — the same code;
+ * - no `notation.local` / `notation.suspend`: the page recalls symbols and
+ *   defines none — code `non-chapter-local-notation`;
+ * - no `$…$` or `[[…]]` in the plain-text strings a page shows outside its
+ *   Markdown body (`hero.title`, `hero.tagline`, a `<PartOverview chain>`
+ *   step), where they would print literally — code `non-chapter-plain-text`.
+ *
+ * A float needs a chapter number, which such a page does not have; linking
+ * the chapter's float (`[[lesson#tab-key]]`) shows it in the reference card
+ * instead. The rule is locked: turning it off would not give the page a
+ * number, so each finding is an error with no waiver. See
+ * docs/authoring/structure-rules.md#s10.
+ */
+
+/** One non-chapter page, as the manifest compiler loads it. */
+interface NonChapterPageInput {
+    readonly file: string;
+    readonly data: Readonly<Record<string, unknown>>;
+    readonly body: string;
+    readonly bodyLine: number;
+}
+/**
+ * Check every non-chapter page for what rule S10 keeps off it. Returns one
+ * `MathGateDiagnostic` (context `'structure'`, always an error) per finding.
+ */
+declare function gateNonChapterPages(pages: readonly NonChapterPageInput[]): MathGateDiagnostic[];
+
+export { type NonChapterPageInput, gateNonChapterPages };