explico 0.13.1 → 0.14.0

package/dist/reference/math-glyphs.mjs

@@ -1082,24 +1082,24 @@ export function isRunningIndexLetter(text) {
   return RUNNING_INDEX_LETTER.test(text);
 }
 
+const isRunningLetterNode = (node) =>
+  node.type === 'mathord' && RUNNING_INDEX_LETTER.test(node.text ?? '');
+
 /**
- * What one index slot is: `running` (a lowercase letter), `digits`, `named`
- * (a `\mathrm{…}` / `\text{…}` label, or a subscript the page declares fixed:
- * an index entry `{}_x`, a letter card with `fixedIndex`), `symbol` (anything
- * else: `N`, `\theta`, `T_{\mathrm{fwd}}`, `t-1`), or `empty`.
+ * What one index slot is: `running` (a lowercase letter), `run` (two or more
+ * juxtaposed lowercase letters, the double index of `x_{ij}`, each a running
+ * letter), `digits`, `named` (a `\mathrm{…}` / `\text{…}` label, or a subscript
+ * the page declares fixed: an index entry `{}_x`, a letter card with
+ * `fixedIndex`), `symbol` (anything else: `N`, `\theta`, `T_{\mathrm{fwd}}`,
+ * `t-1`), or `empty`.
  */
 function slotKind(slot, fixedSlots) {
   if (slot.length === 0) return 'empty';
   if (fixedSlots.has(sequenceSignature(slot))) return 'named';
   if (slot.every(isDigitNode)) return 'digits';
   if (slot.length === 1 && isLabelNode(slot[0])) return 'named';
-  if (
-    slot.length === 1 &&
-    slot[0].type === 'mathord' &&
-    RUNNING_INDEX_LETTER.test(slot[0].text ?? '')
-  ) {
-    return 'running';
-  }
+  if (slot.length === 1 && isRunningLetterNode(slot[0])) return 'running';
+  if (slot.length > 1 && slot.every(isRunningLetterNode)) return 'run';
   return 'symbol';
 }
 
@@ -1168,7 +1168,8 @@ function coreSourceSpan(node, latex) {
  * slots, the same superscript or none on the family, and each slot fits. A
  * running slot takes anything but a fixed label (`x_1`, `x_{k+1}`, `x_N`; not
  * `x_{\mathrm{e}}`), a `symbol` slot any symbol (`T_{\mathrm{opt}}` in place
- * of `T_{\mathrm{fwd}}`), and a fixed slot only itself.
+ * of `T_{\mathrm{fwd}}`), a `run` slot (`x_{ij}`) a run of as many letters
+ * and digits (`x_{i1}`, `x_{12}`, `x_{ji}`), and a fixed slot only itself.
  */
 function isFamilyInstance(family, form, fixedSlots) {
   if (family.form.baseSignature !== form.baseSignature) return false;
@@ -1180,6 +1181,12 @@ function isFamilyInstance(family, form, fixedSlots) {
     const kind = family.kinds[index];
     const filler = form.slots[index];
     const fillerKind = slotKind(filler, fixedSlots);
+    if (kind === 'run') {
+      return (
+        filler.length === slot.length &&
+        filler.every((node) => isRunningLetterNode(node) || isDigitNode(node))
+      );
+    }
     if (kind === 'running' || kind === 'symbol') {
       return fillerKind !== 'named' && fillerKind !== 'empty';
     }
@@ -1462,7 +1469,13 @@ function buildGlyphIndex(definitions) {
   const indexEntries = new Map();
   const headForms = new Map();
   const fixedSlots = new Set();
+  // Who fixed a subscript (rule N23), and the entries marked `fixedIndex`
+  // themselves, so a symbol that would have been a family's instance can say
+  // why it is not (`unresolvedIdentifiers`).
+  const fixedBy = new Map();
+  const fixedEntries = new Set();
   const indexedEntries = [];
+  const indexedForms = new Map();
   // What each bare glyph's indexed entries are, for the message of a symbol
   // that no longer borrows one's card (rule N4).
   const indexedBases = new Map();
@@ -1537,6 +1550,7 @@ function buildGlyphIndex(definitions) {
       }
       indexEntries.set(subscript, key);
       fixedSlots.add(subscript);
+      if (!fixedBy.has(subscript)) fixedBy.set(subscript, { key, via: 'index-entry', notation });
       continue;
     }
 
@@ -1545,10 +1559,14 @@ function buildGlyphIndex(definitions) {
     if (significant.length === 1 && indexedForm(significant[0])) {
       const form = indexedForm(significant[0]);
       indexedEntries.push({ key, form, fixedIndex });
+      if (fixedIndex) fixedEntries.add(key);
+      indexedForms.set(key, form);
       noteIndexedBase(form.baseSignature, key);
     }
     if (fixedIndex && significant.length === 1 && isIdentifierNode(significant[0])) {
-      fixedSlots.add(sequenceSignature(significant));
+      const letter = sequenceSignature(significant);
+      fixedSlots.add(letter);
+      if (!fixedBy.has(letter)) fixedBy.set(letter, { key, via: 'fixedIndex', notation });
     }
     const indexedHead = indexedFunctionHead(tree);
     if (indexedHead) {
@@ -1586,14 +1604,14 @@ function buildGlyphIndex(definitions) {
     }
   }
 
-  // A family is an indexed entry with a running slot (`x_k`, `F_{t,T}`); one
+  // A family is an indexed entry with a running slot (`x_k`, `F_{t,T}`, `x_{ij}`); one
   // whose every slot is fixed (`v_0`, `T_{\mathrm{opt}}`, or `fixedIndex`)
   // is a single symbol and lends its card to nothing.
   const families = new Map();
   for (const { key, form, fixedIndex } of indexedEntries) {
     if (fixedIndex) continue;
     const kinds = form.slots.map((slot) => slotKind(slot, fixedSlots));
-    if (!kinds.includes('running')) continue;
+    if (!kinds.includes('running') && !kinds.includes('run')) continue;
     const list = families.get(form.baseSignature) ?? [];
     list.push({ key, form, kinds });
     families.set(form.baseSignature, list);
@@ -1608,7 +1626,10 @@ function buildGlyphIndex(definitions) {
     indexEntries,
     headForms,
     fixedSlots,
+    fixedBy,
+    fixedEntries,
     families,
+    indexedForms,
     indexedBases,
     maxNodeLength,
   };
@@ -1651,7 +1672,12 @@ function resolveIndexedNode(node, glyphs, source, derive) {
 
   const head = sequenceSignature([node]);
   if (glyphs.headForms.has(head) && !glyphs.ambiguousBase.has(head)) {
-    return { key: glyphs.headForms.get(head), span: whole, match: 'canonical' };
+    return {
+      key: glyphs.headForms.get(head),
+      span: whole,
+      match: 'canonical',
+      sub: sourceSpan(node.sub, source),
+    };
   }
   if (form.sup !== 'none') {
     const signature = coreSignature(form);
@@ -1660,7 +1686,9 @@ function resolveIndexedNode(node, glyphs, source, derive) {
       (glyphs.ambiguousBase.has(signature)
         ? undefined
         : glyphs.headForms.get(signature));
-    if (key !== undefined) return { key, span: core, match: 'canonical' };
+    if (key !== undefined) {
+      return { key, span: core, match: 'canonical', sub: sourceSpan(node.sub, source) };
+    }
   }
 
   const families = (glyphs.families.get(form.baseSignature) ?? []).filter(
@@ -1682,6 +1710,7 @@ function resolveIndexedNode(node, glyphs, source, derive) {
       key: family.key,
       span: family.form.sup !== 'none' ? whole : core,
       match: 'family',
+      sub: sourceSpan(node.sub, source),
     };
   }
 
@@ -1698,6 +1727,33 @@ function resolveIndexedNode(node, glyphs, source, derive) {
   };
 }
 
+/**
+ * The base of each indexed symbol an author wrapped whole in the `\explain` of
+ * an indexed entry with that same base — `\sigma` of
+ * `\explain{component-sd}{\sigma_1}` under the family `\sigma_k`. The wrap
+ * names the indexed symbol, not its base, so the base takes no card of its own
+ * from another entry (a plain `\sigma` on the page): a binding for it would
+ * open the wrong card on the letter. The index inside keeps resolving.
+ */
+function wrappedBaseSpans(indexed, explicitCalls, glyphs, latex, source) {
+  const tight = (span) => (span ? unwrapEnclosingGroupSpan(latex, span) : span);
+  const spans = [];
+  for (const call of explicitCalls) {
+    const entry = glyphs.indexedForms.get(call.key);
+    if (!entry) continue;
+    for (const node of indexed) {
+      const form = indexedForm(node);
+      if (form?.baseSignature !== entry.baseSignature) continue;
+      const exactly = [coreSourceSpan(node, source), sourceSpan(node, source)].some(
+        (span) => span && sameSpan(tight(span), call),
+      );
+      const base = tight(sourceSpan(node.base, source));
+      if (exactly && base) spans.push(base);
+    }
+  }
+  return spans;
+}
+
 /**
  * Bind whole canonical forms: greedy longest match, left to right, per run.
  * A symbol with a subscript that no whole form matches exactly is then
@@ -1716,6 +1772,7 @@ function matchCanonicalForms(
   scriptSpans,
   derive,
   explicitCalls,
+  wrappedBases = [],
 ) {
   const bindings = [];
   const claimed = [];
@@ -1729,6 +1786,7 @@ function matchCanonicalForms(
   };
 
   const blocked = (span, nodes) =>
+    wrappedBases.some((base) => contains(base, span)) ||
     claimed.some(
       (existing) =>
         sameSpan(existing, span) ||
@@ -1755,7 +1813,11 @@ function matchCanonicalForms(
         // or `b'` wraps the decoration too, not just the letter under it.
         const rawSpan = sourceSpan(nodes, strippedSource);
         if (!rawSpan) continue;
-        found = { key, nodes, rawSpan, match: 'canonical' };
+        const sub =
+          nodes.length === 1 && nodes[0].type === 'supsub' && nodes[0].sub
+            ? sourceSpan(nodes[0].sub, strippedSource)
+            : undefined;
+        found = { key, nodes, rawSpan, match: 'canonical', ...(sub ? { sub } : {}) };
         break;
       }
       // A group around one node (an `aligned` cell's) shares that node's
@@ -1788,6 +1850,7 @@ function matchCanonicalForms(
             level: 'scope',
             match: found.match,
             ...(found.derived ? { derived: found.derived } : {}),
+            ...(found.sub ? { sub: found.sub } : {}),
           });
           claimed.push({ ...span, match: found.match });
         }
@@ -1890,26 +1953,109 @@ function injectScopeBindings(latex, bindings) {
   return output;
 }
 
+/** The kinds a slot has when nothing on the page fixes it. */
+const NO_FIXED_SLOTS = new Set();
+
+/**
+ * The families a bare base would have lent its card to, had a card not fixed
+ * the letter their index runs over (rule N23), for a base that is written with
+ * a subscript in the source: `r_2` under the family `r_m` once the card of `m`
+ * says `fixedIndex: true`. The bare `r` is what stays unresolved, and "never a
+ * bare r" would blame the wrong thing, so name the instance and what fixed the
+ * letter. `undefined` when the identifier carries no subscript here, or no
+ * lender fails for that reason.
+ *
+ * @returns {{ instance: string, fixedLenders: Array<{ key: string, via: string, card?: string, letter?: string }> } | undefined}
+ */
+function fixedLendersOf(identifier, lenders, latex, glyphs, indexed) {
+  if (lenders.length === 0) return undefined;
+  const symbol = indexed.find((node) => flattenGroup(node.base)[0] === identifier);
+  const form = symbol === undefined ? undefined : indexedForm(symbol);
+  if (symbol === undefined || form === undefined) return undefined;
+
+  const fixedLenders = [];
+  for (const key of lenders) {
+    const lender = glyphs.indexedForms.get(key);
+    if (lender === undefined) continue;
+    const family = { form: lender, kinds: lender.slots.map((slot) => slotKind(slot, NO_FIXED_SLOTS)) };
+    if (!family.kinds.includes('running') && !family.kinds.includes('run')) continue;
+    if (!isFamilyInstance(family, form, NO_FIXED_SLOTS)) continue;
+    if (glyphs.fixedEntries.has(key)) {
+      fixedLenders.push({ key, via: 'entry' });
+      continue;
+    }
+    for (const slot of lender.slots) {
+      const by = glyphs.fixedBy.get(sequenceSignature(slot));
+      if (by === undefined) continue;
+      fixedLenders.push({ key, via: by.via, card: by.key, letter: by.notation });
+      break;
+    }
+  }
+  if (fixedLenders.length === 0) return undefined;
+  const span = coreSourceSpan(symbol, latex);
+  return {
+    instance: span ? latex.slice(span.start, span.end) : '',
+    fixedLenders,
+  };
+}
+
+/**
+ * The math span a finding sits in, as an author wrote it: `$…$`, whitespace
+ * collapsed, cut at 100 characters. A line number can drift (a loader that
+ * hands over a body, a generated file), but the span can be searched for, so a
+ * message that quotes it still leads to the spot.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export function mathExcerpt(latex) {
+  const flat = String(latex).replace(/\s+/g, ' ').trim();
+  return `$${flat.length > 100 ? `${flat.slice(0, 99)}…` : flat}$`;
+}
+
+/**
+ * What to tell an author whose subscripted symbol a family would have
+ * explained, were its index not fixed (rule N23): the cause, and the repair
+ * that fits it. One sentence, for an unresolved item's `fixedLenders`.
+ *
+ * @param {{ key: string, via: string, card?: string, letter?: string }} lender
+ * @param {string} instance The subscripted symbol as written, `r_2`.
+ * @returns {string}
+ */
+export function fixedLenderMessage(lender, instance) {
+  const own = `give ${instance} an entry of its own (latex: ${instance})`;
+  const lends = `${lender.key} is one symbol and lends its card to nothing, ${instance} included`;
+  switch (lender.via) {
+    case 'entry':
+      return `${instance} would be an instance of ${lender.key}, but ${lender.key} is marked fixedIndex, so it is one symbol and lends its card to nothing (rule N23). Drop fixedIndex there if its index runs over a set, or ${own}.`;
+    case 'index-entry':
+      return `${instance} would be an instance of ${lender.key}, but the index entry ${lender.card} fixes that subscript, so ${lends} (rule N23). Drop that index entry, or ${own}.`;
+    default:
+      return `${instance} would be an instance of ${lender.key}, but ${lender.letter} is marked fixedIndex on ${lender.card}, so ${lends} (rule N23). If ${lender.letter} runs over a set, drop fixedIndex from ${lender.card} and give it a range; if it is a label, ${own}.`;
+  }
+}
+
 /**
  * Every identifier no binding covers, plus every decorated form whose
  * decoration is suspended on this page and that no whole form covers (rule
  * N22). A letter under such a decoration is reported once, as the decorated
  * form (`b''''`, not `b`): that whole form is what needs the entry.
  */
-function unresolvedIdentifiers(latex, identifiers, bindings, suspended, indexedBases) {
+function unresolvedIdentifiers(latex, identifiers, bindings, suspended, glyphs, indexed) {
   const letters = identifiers
     .filter(
       (identifier) =>
         !bindings.some((binding) => contains(binding, identifier)) &&
         !suspended.some((decoration) => contains(decoration.part, identifier)),
     )
-    .map(({ start, end, font, signature }) => {
+    .map(({ node, start, end, font, signature }) => {
       // Report `\mathbb{E}`, not a bare `E`, so the fix hint points at the
       // whole token the author has to wrap in `\explain`.
       const wrapped = expandFontWrapperSpan(latex, { start, end });
       // Rule N23: an indexed entry lends its card to no bare glyph, so name
       // the ones this letter used to borrow from.
-      const lenders = font === undefined ? (indexedBases?.get(signature) ?? []) : [];
+      const lenders = font === undefined ? (glyphs.indexedBases?.get(signature) ?? []) : [];
+      const fixed = fixedLendersOf(node, lenders, latex, glyphs, indexed);
       return {
         token: latex.slice(wrapped.start, wrapped.end),
         // A styled base-library letter (`\mathbf{e}`) is not Euler's number.
@@ -1921,6 +2067,7 @@ function unresolvedIdentifiers(latex, identifiers, bindings, suspended, indexedB
         end: wrapped.end,
         ...(font === undefined ? {} : { font }),
         ...(lenders.length === 0 ? {} : { lenders: [...lenders] }),
+        ...(fixed === undefined ? {} : fixed),
       };
     })
     .filter(({ libraryToken }) => !BASE_LIBRARY.has(libraryToken))
@@ -1954,7 +2101,10 @@ function unresolvedIdentifiers(latex, identifiers, bindings, suspended, indexedB
  *
  * `running` lists the running index letters (`i`, `k`, `t`) in its slots that
  * the page has not declared fixed, with the key of the letter's own card and
- * of the entry that covers the symbol, for the index-set check.
+ * of the entry that covers the symbol, for the index-set check. A letter that
+ * belongs to a larger symbol with its own card (`b` of `b_n` in
+ * `\nabla_{b_n}`) and every letter of a slot that holds a relation
+ * (`\mathbb{E}_{Z\sim g}`, a condition) is not an index and is not listed.
  */
 function classifyIndexed(nodes, context) {
   const { latex, source, bindings, explicitCalls, glyphs, identifiers, unresolved } =
@@ -1978,6 +2128,8 @@ function classifyIndexed(nodes, context) {
     const slots = indexSlots(node.sub).map((slot) => ({
       span: tight(sourceSpan(slot, source)),
       kind: slotKind(slot, glyphs.fixedSlots),
+      // `Z\sim g` in `\mathbb{E}_{Z\sim g}` states a condition, not a position.
+      condition: slot.some((item) => item.type === 'atom' && item.family === 'rel'),
     }));
     const exactly = (span) => sameSpan(span, core) || sameSpan(span, whole);
 
@@ -2037,7 +2189,7 @@ function classifyIndexed(nodes, context) {
     // A swallowed index is already an error; its letters wait for the fix.
     if (!['inside-wrap', 'derived', 'unresolved', 'swallowed'].includes(how)) {
       for (const slot of slots) {
-        if (slot.kind === 'named' || !slot.span) continue;
+        if (slot.kind === 'named' || slot.condition || !slot.span) continue;
         for (const identifier of identifiers) {
           if (identifier.font !== undefined) continue;
           if (identifier.node.type !== 'mathord') continue;
@@ -2049,6 +2201,10 @@ function classifyIndexed(nodes, context) {
                 contains(binding, identifier) && contains(slot.span, binding),
             )
             .sort((left, right) => size(left) - size(right))[0];
+          // A letter inside a larger symbol with a card of its own is part of
+          // that symbol, not an index: `b` of `b_n` in `\nabla_{b_n}`. The
+          // inner symbol is classified in its own right.
+          if (own && own.level === 'scope' && size(own) > size(identifier)) continue;
           running.push({
             letter: identifier.node.text,
             start: identifier.start,
@@ -2420,10 +2576,17 @@ export function resolveMathGlyphs(latex, definitions, options = {}) {
     scriptSpans,
     derive,
     explicitCalls,
+    wrappedBaseSpans(indexed, explicitCalls, glyphs, latex, strippedSource),
   ).filter(
     (binding) =>
       !explicitCalls.some(
-        (call) => overlaps(binding, call) && !contains(call, binding),
+        (call) =>
+          overlaps(binding, call) &&
+          !contains(call, binding) &&
+          // A symbol that holds an `\explain` in its own subscript
+          // (`\beta_{\explain{count}{K}}`) encloses the call whole: the wraps
+          // nest, and the index keeps its card.
+          !(binding.sub !== undefined && contains(binding.sub, call)),
       ),
   );
   const covered = [...canonical, ...explicitCalls];
@@ -2518,7 +2681,8 @@ export function resolveMathGlyphs(latex, definitions, options = {}) {
     identifiers,
     bindings,
     suspendedDecorations,
-    glyphs.indexedBases,
+    glyphs,
+    indexed,
   );
   const derived = new Map();
   for (const binding of bindings) {

package/dist/reference/page-notation.d.ts

@@ -1,8 +1,8 @@
-import { Manifest, ManifestDerivedNotation, ManifestLessonNotation } from '../compiler/manifest.js';
+import { Manifest, ManifestDerivedNotation, ManifestLessonNotation, ManifestLesson } from '../compiler/manifest.js';
 import { DerivedUse } from './types.js';
 import '../curriculum/validation.js';
 import './consistency.js';
-import '../course-config-rRtME5UV.js';
+import '../course-config-BLtIdkei.js';
 import '../rules/catalog.js';
 import '../rules/course-rules.js';
 import '../compiler/collections.js';
@@ -23,6 +23,10 @@ import './mixed-content.js';
 import './gloss.js';
 import '../rules/waivers.js';
 import '../compiler/knowledge-version.js';
+import '../compiler/page-versions.js';
+import '../compiler/decks.js';
+import './decks-validate.js';
+import './deck-source.js';
 import '../compiler/lesson-derivation.js';
 
 interface PageNotationDependency {
@@ -66,6 +70,21 @@ declare function notationKeysInMathNodes(nodes: readonly {
     readonly properties?: Readonly<Record<string, string>>;
     readonly children?: readonly unknown[];
 }[]): string[];
+/**
+ * The compiled notation of a page: a lesson's (a chapter, or a slides-first
+ * lesson's deck), a page that is not a chapter (rule S10), or a deck beside
+ * its chapter (`manifest.decks`, by its page id).
+ */
+declare function pageNotationEntry(manifest: Manifest, pageId: string): {
+    readonly notation: ManifestLesson['notation'];
+} | undefined;
+/**
+ * The lessons whose `notation.local` a page's symbols bind in, the first to
+ * define a key binding it (`NotationLessonInput.scopeLessonIds`): a lesson's
+ * deck's is its lesson; a part's deck's, every chapter of the part in
+ * reading order; any other page's, its own.
+ */
+declare function scopeLessonsOf(manifest: Manifest, pageId: string): readonly string[];
 /**
  * The derived cards (rule N23) a page uses: the ones its body and assessment
  * math use, as the manifest composed them, and the ones a lab or a diagram on
@@ -86,4 +105,4 @@ declare function notationDefinitionsForRenderedPage(manifest: Manifest, pageId:
  */
 declare function missingNotationPayloadKeys(html: string): string[];
 
-export { type PageNotationDependency, type ScopePage, bindScopeToPage, derivedNotationForPage, missingNotationPayloadKeys, notationDefinitionsForRenderedPage, notationKeysInMathNodes, pageNotationDependencies, pageOfScope, registerPageDerivedNotation, registerPageNotationDependencies, routeIdFromLocals };
+export { type PageNotationDependency, type ScopePage, bindScopeToPage, derivedNotationForPage, missingNotationPayloadKeys, notationDefinitionsForRenderedPage, notationKeysInMathNodes, pageNotationDependencies, pageNotationEntry, pageOfScope, registerPageDerivedNotation, registerPageNotationDependencies, routeIdFromLocals, scopeLessonsOf };

package/dist/reference/page-notation.js

@@ -2,9 +2,18 @@ import {
   formulaExplainKeys,
   formulaGlyphScope
 } from "./gloss.js";
-import { resolveReferenceId } from "./references.js";
+import { resolvePageReferenceId, resolveReferenceId } from "./references.js";
 import { derivedNotationEntries } from "./derived-entries.js";
-const dependenciesByLocals = /* @__PURE__ */ new WeakMap();
+const REGISTRY_KEY = /* @__PURE__ */ Symbol.for("explico.reference.page-notation");
+function sharedRegistry() {
+  const host = globalThis;
+  return host[REGISTRY_KEY] ??= {
+    dependenciesByLocals: /* @__PURE__ */ new WeakMap(),
+    derivedByLocals: /* @__PURE__ */ new WeakMap(),
+    pageByScope: /* @__PURE__ */ new WeakMap()
+  };
+}
+const { dependenciesByLocals, derivedByLocals, pageByScope } = sharedRegistry();
 function registerPageNotationDependencies(locals, keys, context) {
   let byKey = dependenciesByLocals.get(locals);
   if (!byKey) {
@@ -20,7 +29,6 @@ function registerPageNotationDependencies(locals, keys, context) {
     contexts.add(context);
   }
 }
-const derivedByLocals = /* @__PURE__ */ new WeakMap();
 function registerPageDerivedNotation(locals, uses, context) {
   let byKey = derivedByLocals.get(locals);
   if (!byKey) {
@@ -34,7 +42,6 @@ function registerPageDerivedNotation(locals, uses, context) {
   }
   registerPageNotationDependencies(locals, entries, context);
 }
-const pageByScope = /* @__PURE__ */ new WeakMap();
 function bindScopeToPage(scope, page) {
   pageByScope.set(scope, page);
 }
@@ -88,8 +95,21 @@ function manifestDefinition(definition, cardsByKey) {
     ...definition.range === void 0 ? {} : { range: definition.range }
   };
 }
+function pageNotationEntry(manifest, pageId) {
+  return manifest.lessons.find((entry) => entry.id === pageId) ?? manifest.pages.find((entry) => entry.id === pageId) ?? (manifest.decks ?? []).find((entry) => entry.pageId === pageId);
+}
+function scopeLessonsOf(manifest, pageId) {
+  const deck = (manifest.decks ?? []).find((entry) => entry.pageId === pageId);
+  if (deck?.part !== void 0) {
+    const chapters = new Set(
+      manifest.lessons.filter((lesson) => (lesson.editions ?? ["chapter"]).includes("chapter")).map((lesson) => lesson.id)
+    );
+    return (manifest.parts.find((part) => part.dir === deck.part)?.lessons ?? []).filter((id) => chapters.has(id));
+  }
+  return [deck?.lessonId ?? pageId];
+}
 function derivedNotationForPage(manifest, pageId, locals) {
-  const page = manifest.lessons.find((entry) => entry.id === pageId) ?? manifest.pages.find((entry) => entry.id === pageId);
+  const page = pageNotationEntry(manifest, pageId);
   const compiled = page?.notation.derived ?? [];
   const registered = [...(locals && derivedByLocals.get(locals)?.values()) ?? []].filter(
     (use) => !compiled.some((entry) => entry.key === use.key)
@@ -102,7 +122,7 @@ function derivedNotationForPage(manifest, pageId, locals) {
   const records = /* @__PURE__ */ new Map();
   for (const use of registered) {
     for (const key of [use.base, use.index]) {
-      const id = resolveReferenceId(key, { kind: "page", lessonId: pageId }, availableIds);
+      const id = resolvePageReferenceId(key, scopeLessonsOf(manifest, pageId), availableIds);
       const record = id === void 0 ? void 0 : definitionsById.get(id);
       if (record) records.set(key, record);
     }
@@ -115,7 +135,7 @@ function derivedNotationForPage(manifest, pageId, locals) {
   );
 }
 function notationDefinitionsForRenderedPage(manifest, pageId, dependencies) {
-  const page = manifest.lessons.find((entry) => entry.id === pageId) ?? manifest.pages.find((entry) => entry.id === pageId);
+  const page = pageNotationEntry(manifest, pageId);
   if (!page) return [];
   const definitionsById = new Map(
     manifest.notation.definitions.map((definition) => [definition.id, definition])
@@ -130,9 +150,9 @@ function notationDefinitionsForRenderedPage(manifest, pageId, dependencies) {
       contextsByKey.set(dependency.key, contexts);
     }
     contexts.add(dependency.context);
-    const definitionId = resolveReferenceId(
+    const definitionId = resolvePageReferenceId(
       dependency.key,
-      { kind: "page", lessonId: pageId },
+      scopeLessonsOf(manifest, pageId),
       availableIds
     );
     if (!definitionId) {
@@ -216,8 +236,10 @@ export {
   notationDefinitionsForRenderedPage,
   notationKeysInMathNodes,
   pageNotationDependencies,
+  pageNotationEntry,
   pageOfScope,
   registerPageDerivedNotation,
   registerPageNotationDependencies,
-  routeIdFromLocals
+  routeIdFromLocals,
+  scopeLessonsOf
 };

package/dist/reference/references.d.ts

@@ -21,7 +21,20 @@ declare function definitionId(scope: NotationDefinitionScope, key: string): stri
  * can only see shared definitions, so their meaning cannot change by caller.
  */
 declare function resolveReferenceId(key: string, scope: NotationDefinitionScope, availableDefinitionIds: ReadonlySet<string>): string | undefined;
+/**
+ * Resolve on a page whose symbols bind in several lessons' scopes, as a
+ * part's deck binds in its chapters' (`NotationLessonInput.scopeLessonIds`):
+ * the first lesson's local entry for the key, then the next lesson's, then
+ * the shared entry. With one lesson it is {@link resolveReferenceId}'s page
+ * scope.
+ */
+declare function resolvePageReferenceId(key: string, lessonIds: readonly string[], availableDefinitionIds: ReadonlySet<string>): string | undefined;
+/** The lessons whose `notation.local` a page's symbols bind in: a deck's, or the page's own. */
+declare function pageScopeLessonIds(lesson: {
+    readonly lessonId: string;
+    readonly scopeLessonIds?: readonly string[];
+}): readonly string[];
 declare function compareSourceSpans(left: SourceSpan | undefined, right: SourceSpan | undefined): number;
 declare function compareDiagnostics(left: NotationDiagnostic, right: NotationDiagnostic): number;
 
-export { NOTATION_KEY_PATTERN, RESERVED_KEY_PREFIXES, compareDiagnostics, compareSourceSpans, definitionId, isNotationKey, localDefinitionId, reservedKeyPrefix, resolveReferenceId, sharedDefinitionId };
+export { NOTATION_KEY_PATTERN, RESERVED_KEY_PREFIXES, compareDiagnostics, compareSourceSpans, definitionId, isNotationKey, localDefinitionId, pageScopeLessonIds, reservedKeyPrefix, resolvePageReferenceId, resolveReferenceId, sharedDefinitionId };

package/dist/reference/references.js

@@ -23,6 +23,17 @@ function resolveReferenceId(key, scope, availableDefinitionIds) {
   const sharedId = sharedDefinitionId(key);
   return availableDefinitionIds.has(sharedId) ? sharedId : void 0;
 }
+function resolvePageReferenceId(key, lessonIds, availableDefinitionIds) {
+  for (const lessonId of lessonIds) {
+    const localId = localDefinitionId(lessonId, key);
+    if (availableDefinitionIds.has(localId)) return localId;
+  }
+  const sharedId = sharedDefinitionId(key);
+  return availableDefinitionIds.has(sharedId) ? sharedId : void 0;
+}
+function pageScopeLessonIds(lesson) {
+  return lesson.scopeLessonIds ?? [lesson.lessonId];
+}
 function compareSourceSpans(left, right) {
   if (left === void 0) return right === void 0 ? 0 : 1;
   if (right === void 0) return -1;
@@ -43,7 +54,9 @@ export {
   definitionId,
   isNotationKey,
   localDefinitionId,
+  pageScopeLessonIds,
   reservedKeyPrefix,
+  resolvePageReferenceId,
   resolveReferenceId,
   sharedDefinitionId
 };

package/dist/reference/registry-scope.d.mts

@@ -0,0 +1,33 @@
+/**
+ * The glyph table a notation entry's Markdown body resolves against, and the
+ * advice for a symbol it does not bind. The remark pass renders an entry's
+ * body with this table (`remark-notation.mjs`) and `validate:content` checks
+ * the same body with it (`gate-math.ts`), so the fast gate and the build read
+ * one table and cannot disagree on what binds.
+ *
+ * The table is every shared entry. An entry's body has no `notation.local`,
+ * names its neighbours without `[[key]]`, suspends no decoration (rule N22)
+ * and derives no cards (rule N23, a page's own): resolve it with
+ * `{ suspended: [], derive: false }`.
+ */
+/**
+ * One row per shared definition. `fixedIndex` is kept (rule N23): an entry
+ * whose index is a fixed label is no family, in an entry's body as on a page.
+ *
+ * @param {Iterable<{ readonly key: string; readonly notation: string; readonly fixedIndex?: boolean }>} definitions
+ * @returns {{ key: string; notation: string; fixedIndex?: true }[]}
+ */
+export function registryGlyphScope(definitions: Iterable<{
+    readonly key: string;
+    readonly notation: string;
+    readonly fixedIndex?: boolean;
+}>): {
+    key: string;
+    notation: string;
+    fixedIndex?: true;
+}[];
+/**
+ * Every shared entry is already in scope, so neither `[[key]]` nor
+ * `notation.local` can bind a symbol the table missed.
+ */
+export const REGISTRY_BODY_FIX: "A notation entry\u2019s body binds every shared entry and nothing else: give the symbol an entry of its own in content/notation/, or wrap it in \\explain{key}{latex} with the entry it stands for.";