@heroiclands/package-build 23.8.0 → 23.9.0

package/engine/dictionary-rows.mjs

@@ -36,19 +36,19 @@
  * where it is a word of its language compared without case. A title of
  * several words, joined by a space or a hyphen, always is.
  *
- * **A glossary entry with a `definition`** replaces the senses of its owner's
- * own rank or office of that name, and otherwise is a term of its owner's own,
- * cited from the owner. **An entry without one** marks what it names: the term
- * of its name in the language it resolves to
- * ({@link module:engine/glossary-language}), among the words and the ranks and
- * offices that reach its note, and failing that the term of its name in any
- * language that reaches it. Marking sets `common`, and replaces `name_sort`
- * and `pronunciation`, on the word's row in that language or on the rank's or
- * office's row.
+ * **A glossary entry naming a dictionary word** carries the word's class and
+ * a link to its entry in the resolved language's dictionary. Without a
+ * `definition` it carries the word's senses; with one it carries that sense
+ * instead. An owner's own rank or office contributes its descriptions after
+ * the word's senses, unless the entry states a definition. An entry naming
+ * another body's rank or office carries its senses on the entry's own row.
+ * `common`, `name_sort` and `pronunciation` belong to each owner's entry;
+ * nothing a glossary states changes a dictionary word.
  *
  * @module
  */
 
+import { createHash } from "node:crypto";
 import { parseAddress, renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
 import { isNoteRecord } from "./index-records.mjs";
@@ -65,10 +65,12 @@ export const DICTIONARY_COLUMNS = Object.freeze([
     "letter",
     "pronunciation",
     "class",
+    "plural",
+    "field",
     "etymology",
     "senses",
     "usage",
-    "common",
+    "verbs",
     "depth",
 ]);
 
@@ -82,6 +84,8 @@ export const TERM_COLUMNS = Object.freeze([
     "name_sort",
     "letter",
     "pronunciation",
+    "class",
+    "word",
     "senses",
     "usage",
     "common",
@@ -126,6 +130,34 @@ const isSingleWord = (title) => !/[\s\-‐‑]/u.test(title);
 /** Whether a glossary entry states a definition. */
 const defines = (entry) => typeof entry.definition === "string" && entry.definition.trim() !== "";
 
+/** A noun's stated plural, or the first literal ending replacement that fits. */
+function pluralOf(word, grammar) {
+    if (parseWordClass(word.class).base !== "n") return null;
+    if (typeof word.plural === "string" && word.plural) return word.plural;
+    for (const rule of Array.isArray(grammar?.plural) ? grammar.plural : []) {
+        if (typeof rule?.ending !== "string" || typeof rule.becomes !== "string") continue;
+        if (word.form.endsWith(rule.ending))
+            return (
+                (rule.ending ? word.form.slice(0, -rule.ending.length) : word.form) + rule.becomes
+            );
+    }
+    return null;
+}
+
+/**
+ * The stable prose anchor of a word in one language's dictionary. The exact
+ * language and NFC form identify it, including case and accents.
+ *
+ * @param {string} language - The language's canonical note Address.
+ * @param {string} name - The dictionary headword.
+ * @returns {string} The anchor slug.
+ */
+export function dictionaryEntryAnchor(language, name) {
+    return `word-${createHash("sha256")
+        .update(JSON.stringify([language, nfc(name)]))
+        .digest("hex")}`;
+}
+
 /**
  * The heading letter of a sort key: its first letter or digit, accents taken
  * off and apostrophes skipped, in capitals; `#` where it has none.
@@ -259,10 +291,11 @@ export function dictionaryAndTermRows(records, all = records) {
         byForm.set(key, exact);
         byLowerForm.set(key, lower);
     }
-    /** The word of a form as a language lists it, nearest in its lineage first. */
+    /** A form's nearest visible definition, traversing the complete lineage. */
     const wordIn = (language, name) => {
         const chain = lineage(language);
         for (let depth = 0; depth < chain.length; depth++) {
+            if (!visible.has(chain[depth])) continue;
             const word = byForm.get(chain[depth]).get(name);
             if (word) return { word, statedIn: chain[depth], depth };
         }
@@ -377,7 +410,7 @@ export function dictionaryAndTermRows(records, all = records) {
     }
     const allGovernance = [...governance.values()].flatMap((rows) => [...rows.values()]);
 
-    // ── Word rows, before marks ──────────────────────────────────────────────
+    // ── Word rows ────────────────────────────────────────────────────────────
     const wordRows = new Map();
     const wordKey = (language, name) => `${language}\0${name}`;
     for (const [language] of languages) {
@@ -388,7 +421,7 @@ export function dictionaryAndTermRows(records, all = records) {
                 const name = nfc(word.form);
                 const key = wordKey(language, name);
                 if (wordRows.has(key)) continue;
-                wordRows.set(key, { language, name, found: wordIn(language, name), marks: [] });
+                wordRows.set(key, { language, name, found: wordIn(language, name) });
             }
         }
     }
@@ -404,48 +437,35 @@ export function dictionaryAndTermRows(records, all = records) {
             culture ?
                 allGovernance.filter((row) => row.cultures.includes(note))
             :   [...(governance.get(note)?.values() ?? [])];
-        const reachLanguages = new Set([
-            languageOf(record, note, undefined),
-            ...(culture ? reach.map((row) => row.language) : []),
-        ]);
-        reachLanguages.delete(null);
         glossaryOf(note).forEach((entry, position) => {
             const name = nfc(entry.name);
             const language = languageOf(record, note, entry);
             const mark = { note, position, entry };
-            if (defines(entry)) {
-                const own = !culture ? governance.get(note)?.get(name) : undefined;
-                if (own) {
-                    own.definition = mark;
-                    own.marks.push(mark);
-                    own.named = true;
-                } else
-                    owned.push({
-                        owner: note,
-                        ownerKind: culture ? "culture" : "affiliation",
-                        language,
-                        name,
-                        cultures: culture ? [note] : culturesOf(note),
-                        mark,
-                    });
+            const found = wordRows.get(wordKey(language, name))?.found;
+            const own = !culture ? governance.get(note)?.get(name) : undefined;
+            if (own) {
+                own.language = language;
+                own.found = found;
+                if (defines(entry)) own.definition = mark;
+                own.marks.push(mark);
+                own.named = true;
                 return;
             }
-            const stated = typeof entry.language === "string" && entry.language;
-            const among = stated ? new Set([language]) : reachLanguages;
-            const found = [];
-            for (const candidate of among)
-                if (wordIn(candidate, name)) {
-                    const row = wordRows.get(wordKey(candidate, name));
-                    if (row) found.push({ language: candidate, row });
-                }
-            for (const row of reach)
-                if (row.name === name && among.has(row.language))
-                    found.push({ language: row.language, row });
-            const preferred = found.filter((one) => one.language === language);
-            for (const { row } of preferred.length ? preferred : found) {
-                row.marks.push(mark);
-                row.named = true;
-            }
+            const reached = reach.filter((row) => row.name === name);
+            const preferred = reached.filter((row) => row.language === language);
+            const providers = preferred.length ? preferred : reached;
+            if (!defines(entry)) for (const row of providers) row.named = true;
+            if (defines(entry) || found || providers.length)
+                owned.push({
+                    owner: note,
+                    ownerKind: culture ? "culture" : "affiliation",
+                    language,
+                    name,
+                    cultures: culture ? [note] : culturesOf(note),
+                    found,
+                    providers: found || defines(entry) ? [] : providers,
+                    mark,
+                });
         });
     }
 
@@ -484,38 +504,50 @@ export function dictionaryAndTermRows(records, all = records) {
 
     const citedBy = citationLookup(byKey.values());
     const dictionary = [];
-    for (const { language, name, found, marks } of wordRows.values()) {
-        const { word, depth, statedIn } = found;
+    const wordUsage = ({ word, statedIn }) =>
+        [...new Set(citedBy(statedIn, word.form).filter(citable))].sort(compare);
+    for (const { language, name, found } of wordRows.values()) {
+        const { word, depth } = found;
+        const grammar = languages.get(language)?.data?.grammar;
         const nameSort =
-            marked(marks, "name_sort") ??
-            (typeof word.name_sort === "string" && word.name_sort ? word.name_sort : name);
+            typeof word.name_sort === "string" && word.name_sort ? word.name_sort : name;
         dictionary.push({
             language,
             language_tag: tagOf(language),
             name,
             name_sort: nameSort,
             letter: dictionaryLetter(nameSort),
-            pronunciation:
-                marked(marks, "pronunciation") ??
-                (typeof word.pronunciation === "string" ? word.pronunciation : null),
+            pronunciation: typeof word.pronunciation === "string" ? word.pronunciation : null,
             class: typeof word.class === "string" ? word.class : null,
+            plural: pluralOf(word, grammar),
+            field: typeof word.field === "string" ? word.field : null,
             etymology: etymologyOf(found),
             senses: glossSenses(word.gloss).map((text) => ({ text, bodies: [] })),
-            usage: [...new Set(citedBy(statedIn, word.form).filter(citable))].sort(compare),
-            common: marks.some((one) => one.entry.common === true),
+            usage: wordUsage(found),
+            verbs: isMap(grammar?.verbs) ? grammar.verbs : null,
             depth,
         });
     }
 
     const terms = [];
     const termRow = (
-        { owner, ownerKind, language, name, cultures },
+        { owner, ownerKind, language, name, cultures, found },
         senses,
         usage,
         marks,
         origins,
     ) => {
-        const nameSort = marked(marks, "name_sort") ?? name;
+        const word = found?.word;
+        const wordLanguage =
+            (
+                Array.isArray(languages.get(language)?.data?.words) &&
+                languages.get(language).data.words.length
+            ) ?
+                language
+            :   found?.statedIn;
+        const nameSort =
+            marked(marks, "name_sort") ??
+            (typeof word?.name_sort === "string" && word.name_sort ? word.name_sort : name);
         terms.push({
             owner,
             owner_kind: ownerKind,
@@ -524,7 +556,9 @@ export function dictionaryAndTermRows(records, all = records) {
             name,
             name_sort: nameSort,
             letter: dictionaryLetter(nameSort),
-            pronunciation: marked(marks, "pronunciation") ?? null,
+            pronunciation: marked(marks, "pronunciation") ?? word?.pronunciation ?? null,
+            class: word?.class ?? null,
+            word: found ? `${wordLanguage}#${dictionaryEntryAnchor(wordLanguage, name)}` : null,
             senses,
             usage: [...new Set(usage)].filter(citable).sort(compare),
             common: marks.some((one) => one.entry.common === true),
@@ -532,34 +566,50 @@ export function dictionaryAndTermRows(records, all = records) {
             cultures,
         });
     };
+    const combineSenses = (senses) => {
+        const combined = [];
+        for (const sense of senses) {
+            const same = combined.find((one) => one.text === sense.text);
+            if (!same) combined.push({ ...sense, bodies: [...sense.bodies] });
+            else
+                for (const body of sense.bodies)
+                    if (!same.bodies.includes(body)) same.bodies.push(body);
+        }
+        return combined;
+    };
+    const governanceSenses = (row) => {
+        if (row.definition) return [{ text: row.definition.entry.definition, bodies: [row.owner] }];
+        return combineSenses([
+            ...glossSenses(row.found?.word.gloss).map((text) => ({ text, bodies: [] })),
+            ...[...row.pieces]
+                .sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind])
+                .filter((piece) => piece.text?.trim())
+                .map((piece) => ({ text: piece.text, bodies: [row.owner] })),
+        ]);
+    };
     for (const row of allGovernance) {
         const enters =
             !isSingleWord(row.name) ||
             row.named ||
             (row.language !== null && hasWordIgnoringCase(row.language, row.name));
         if (!enters) continue;
-        const senses = [];
-        if (row.definition)
-            senses.push({ text: row.definition.entry.definition, bodies: [row.owner] });
-        else
-            for (const piece of [...row.pieces].sort(
-                (a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind],
-            ))
-                if (piece.text?.trim() && !senses.some((sense) => sense.text === piece.text))
-                    senses.push({ text: piece.text, bodies: [row.owner] });
-        termRow(row, senses, [...row.usage], row.marks, [
+        termRow(row, governanceSenses(row), [...row.usage], row.marks, [
             ...row.pieces.map((piece) => piece.kind),
             ...(row.marks.length ? ["glossary"] : []),
         ]);
     }
-    for (const one of owned)
-        termRow(
-            one,
-            [{ text: one.mark.entry.definition, bodies: [one.owner] }],
-            [one.owner],
-            [one.mark],
-            ["glossary"],
-        );
+    for (const one of owned) {
+        const defined = defines(one.mark.entry);
+        const senses =
+            defined ? [{ text: one.mark.entry.definition, bodies: [one.owner] }]
+            : one.found ? glossSenses(one.found.word.gloss).map((text) => ({ text, bodies: [] }))
+            : combineSenses(one.providers.flatMap(governanceSenses));
+        const usage =
+            defined ? [one.owner]
+            : one.found ? wordUsage(one.found)
+            : [one.owner, ...one.providers.flatMap((row) => [...row.usage])];
+        termRow(one, senses, usage, [one.mark], ["glossary"]);
+    }
 
     dictionary.sort(
         (a, b) =>

package/engine/foundry-entries.mjs

@@ -78,6 +78,8 @@ import { isHomepage } from "./homepage.mjs";
 import { declaresNoPack } from "./pack-router.mjs";
 import { assertNoDeclaredPackage } from "./note-package.mjs";
 import { collectAnchors } from "./anchors.mjs";
+import { scanSpans } from "./content-spans.mjs";
+import { DICTIONARY_ENTRY_CLASS } from "./dictionary-layout.mjs";
 import { journalPageId, splitPages } from "./journals.mjs";
 import { routerFor } from "./pack-router.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
@@ -94,7 +96,9 @@ import { publishesContentPages } from "../content-config.mjs";
 export const LEAD_ANCHOR = "$lead";
 
 /**
- * Every page of a note's journal, as `anchorName → whole UUID`.
+ * Every anchor of a note's journal, as `anchorName → Foundry target`.
+ * A dictionary word's native heading carries its fragment after the
+ * containing page's UUID.
  *
  * Whole, not a fragment appended to the entry's UUID: nothing owns a page
  * address, so a complete link restates no fact, and it keeps the page-id hash
@@ -112,9 +116,20 @@ export function anchorsOf(entryUuid, entryId, body, name) {
     const anchors = {};
     splitPages(body, name).forEach((page, index) => {
         const uuid = pageUuid(entryUuid, journalPageId(entryId, page));
+        const words = new Set(
+            scanSpans(page.markdown)
+                .spans.filter((span) =>
+                    span.attrs.some(
+                        ([key, value]) =>
+                            key === "class" && value.split(/\s+/).includes(DICTIONARY_ENTRY_CLASS),
+                    ),
+                )
+                .map((span) => span.id),
+        );
         if (index === 0) anchors[LEAD_ANCHOR] = uuid;
         if (page.anchorSlug) anchors[page.anchorSlug] = uuid;
-        for (const anchor of collectAnchors(page.markdown)) anchors[anchor.slug] = uuid;
+        for (const anchor of collectAnchors(page.markdown))
+            anchors[anchor.slug] = words.has(anchor.slug) ? `${uuid}#${anchor.slug}` : uuid;
     });
     return anchors;
 }
@@ -290,7 +305,10 @@ export function entriesForNote(fm, name, address, body, ctx) {
             id: fm.id,
             uuid: own,
             systemUuids: systemUuidsFor(fm.type, fm.id),
-            anchors: own && fm.type === "doc" ? anchorsOf(own, fm.id, body ?? "", name) : undefined,
+            anchors:
+                own && packForType(fm.type)?.docType === "JournalEntry" ?
+                    anchorsOf(own, fm.id, body ?? "", name)
+                :   undefined,
         },
     ];
 }

package/engine/glossary-entries.mjs

@@ -16,12 +16,12 @@
  * `lore` note of `subType: culture` or on an `affiliation`, a list of
  * `{ name, name_sort?, common?, definition?, pronunciation?, language? }`.
  *
- * It holds the terms that belong to the people or body using them rather than
- * to a language's grammar: euphemisms, idioms, terms of art, and titles that
- * are not ranks. An entry with a `definition` creates a term or replaces every
- * sense the term's other sources give it. An entry without one changes no
- * sense, and only marks a term the note already has — a word of a language
- * that reaches it, or a rank or office — as common, sorted or pronounced.
+ * An entry chooses a common word, gives a dictionary word a contextual
+ * meaning, or defines a phrase, compound or term of art. An entry naming a
+ * word of its resolved language carries that word's senses and class unless
+ * its own `definition` supplies the sense. A rank or office can also be named.
+ * Common marks, sort keys and pronunciation overrides belong to the entry's
+ * own glossary.
  *
  * The shape is the inner-key check's; this check owns what an entry means:
  *
@@ -88,7 +88,7 @@ export function checkGlossary(note, { index } = {}) {
     if (!Array.isArray(data.glossary)) return [];
 
     const findings = [];
-    const terms = index?.notes ? noteTerms(index, note) : undefined;
+    const hasTerms = Boolean(index?.notes);
     const seen = new Set();
     data.glossary.forEach((entry, i) => {
         if (!isMap(entry) || typeof entry.name !== "string" || !entry.name.trim()) return;
@@ -116,7 +116,7 @@ export function checkGlossary(note, { index } = {}) {
                     ),
                 );
         }
-        if (!terms) return;
+        if (!hasTerms) return;
         const stated = entry.language !== undefined && entry.language !== null;
         const named = stated ? languageProblem(index, entry.language) : undefined;
         if (named) findings.push(at([i, "language"], "error", named));
@@ -133,15 +133,15 @@ export function checkGlossary(note, { index } = {}) {
                         "; state `language` on the entry or `data.language` on the note",
                 ),
             );
-        const senses = terms.get(name);
+        const senses = noteTerms(index, note, entry).get(name);
         const defined = typeof entry.definition === "string" && entry.definition.trim() !== "";
         if (!defined && !senses)
             findings.push(
                 at(
                     [i, "name"],
                     "error",
-                    `\`${entry.name}\` names nothing: it is no word of a language that reaches ` +
-                        "this note and no rank or office it holds, and the entry gives no " +
+                    `\`${entry.name}\` names nothing: it is no word of its resolved language ` +
+                        "and no rank or office that reaches this note, and the entry gives no " +
                         "`definition` to make it a term",
                 ),
             );

package/engine/heading-attributes.mjs

@@ -28,12 +28,26 @@
  * **A leaf, deliberately.** `anchors.mjs` is shared by the compilers, the index
  * and the link checker and cannot import any of them; the figure pass is
  * imported by `anchors.mjs` and so cannot import it back. A module that imports
- * only the attribute grammar can be asked by all of them.
+ * the attribute grammar and Markdown literal ranges can be asked by all of them.
  *
  * @module
  */
 
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
+import MarkdownIt from "markdown-it";
+
+/** Literal block ranges use the renderer's Markdown grammar. */
+const structureParser = new MarkdownIt({ html: true });
+
+/** Body lines occupied by code or raw HTML, including comment examples. */
+function literalHeadingLines(source) {
+    const lines = new Set();
+    for (const token of structureParser.parse(String(source ?? ""), {})) {
+        if (!token.map || !["fence", "code_block", "html_block"].includes(token.type)) continue;
+        for (let line = token.map[0]; line < token.map[1]; line++) lines.add(line);
+    }
+    return lines;
+}
 
 /**
  * A heading line: its hashes and the text after them.
@@ -134,8 +148,8 @@ export function opensPage({ level, id }) {
 /**
  * Every heading in a body, with what its attribute block declares.
  *
- * Fenced code is skipped: `#` opens a comment in most of what gets fenced, and
- * an example heading in a document is not a heading of it.
+ * Code and raw HTML blocks are skipped: an example heading in a document is
+ * not a heading of it, including an example in an HTML comment.
  *
  * @param {string} source - A note's markdown body.
  * @param {number} [bodyLine=1] - The 1-based file line the body starts on, so a
@@ -148,18 +162,9 @@ export function scanHeadingAttributes(source, bodyLine = 1) {
     const lines = String(source ?? "").split("\n");
     const headings = [];
     const errors = [];
-    let codeFence = null;
+    const literal = literalHeadingLines(source);
     for (let i = 0; i < lines.length; i++) {
-        const fence = /^ {0,3}(`{3,}|~{3,})/.exec(lines[i]);
-        if (codeFence) {
-            if (fence && fence[1][0] === codeFence[0] && fence[1].length >= codeFence.length)
-                codeFence = null;
-            continue;
-        }
-        if (fence) {
-            codeFence = fence[1];
-            continue;
-        }
+        if (literal.has(i)) continue;
         const heading = HEADING_LINE.exec(lines[i]);
         if (!heading) continue;
         const parsed = splitHeadingAttributes(heading[2]);
@@ -267,21 +272,9 @@ export function parseHeadingLine(line) {
 export function pageOpenings(source, blockLines = new Set()) {
     const lines = String(source ?? "").split("\n");
     const openings = new Map();
-    let codeFence = null;
+    const literal = literalHeadingLines(source);
     for (const [index, line] of lines.entries()) {
-        // A fence's closer must carry the same character as its opener and
-        // be at least as long, same as {@link scanHeadingAttributes} tracks
-        // it below — a longer fence is what lets a fenced example carry a
-        // shorter fence of its own as literal content.
-        const fence = /^ {0,3}(`{3,}|~{3,})/.exec(line);
-        if (codeFence) {
-            if (fence && fence[1][0] === codeFence[0] && fence[1].length >= codeFence.length) {
-                codeFence = null;
-            }
-        } else if (fence) {
-            codeFence = fence[1];
-        }
-        if (codeFence !== null || blockLines.has(index)) continue;
+        if (literal.has(index) || blockLines.has(index)) continue;
         const heading = parseHeadingLine(line);
         if (!heading?.startsPage) continue;
         openings.set(index, { ...heading, line: index + 1 });

package/engine/helpers.mjs

@@ -74,6 +74,7 @@ import { isDraftNote } from "./note-vocabulary.mjs";
 import { DERIVED_PACKED_TYPES, NEVER_PACKED_TYPES } from "./note-claims.mjs";
 import { expandContentTables } from "./content-tables.mjs";
 import { spanMarkdownPlugin } from "./content-spans.mjs";
+import { dictionaryEntryPlugin } from "./dictionary-layout.mjs";
 import { renderBlocks } from "./content-blocks.mjs";
 import { headingAttributesPlugin } from "./heading-attributes.mjs";
 import { renderFigureBlocks, scanFigures } from "./content-figures.mjs";
@@ -108,6 +109,7 @@ export const md = markdownit({ html: true })
     .use(footnotePlugin)
     .use(deflistPlugin)
     .use(spanMarkdownPlugin)
+    .use(dictionaryEntryPlugin)
     // A heading's attribute block, written onto the heading element rather than
     // typeset into it — the reading the website's renderer does for itself.
     .use(headingAttributesPlugin)
@@ -781,12 +783,14 @@ import { collectAnchors } from "./anchors.mjs";
  *   omitted.
  * @param {readonly object[]} [opts.records] - The corpus, derived once per
  *   compile and handed in. Required: see {@link assertSuppliedCorpus}.
+ * @param {Map<string, object[]>} [opts.sqlTables] - Prepared directives,
+ *   including the anchors and Foundry page maps of their expanded bodies.
  * @returns {{byShortcode: Map, types: Set}} From `buildWikilinkIndex`.
  */
 export function buildContentLinkIndex(
     contentBase,
     router = packRouter(),
-    { config, records } = {},
+    { config, records, sqlTables } = {},
 ) {
     const docs = [];
     /** The files this package ships, by canonical address. */
@@ -812,6 +816,7 @@ export function buildContentLinkIndex(
         // authored fields, and neither may be handed the keys the index derived.
         const fm = authoredFrontmatter(record);
         const absPath = noteFile(contentBase, record);
+        const prepared = sqlTables?.get(absPath);
         // The id a note's document is filed under: its authored pin, or the
         // one derived from its canonical address. Derived by the index
         // against the configuration this build resolved — never here through
@@ -861,11 +866,12 @@ export function buildContentLinkIndex(
             // discarded here — the walk yields the body and nothing read it.
             // Read from the record rather than from a second reading of the
             // note's headings — the one-anchor-reader rule.
-            anchors: new Set(
-                (record.anchors ?? [])
+            anchors: new Set([
+                ...(record.anchors ?? [])
                     .filter((anchor) => anchor.kind === "prose")
                     .map((anchor) => anchor.slug),
-            ),
+                ...(prepared?.anchors ?? []).map((anchor) => anchor.slug),
+            ]),
             // The note's event ids, which a wikilink may not name: a link to
             // one is refused with its own message rather than as unknown.
             eventAnchors: new Set(
@@ -873,8 +879,8 @@ export function buildContentLinkIndex(
                     .filter((anchor) => anchor.kind === "event")
                     .map((anchor) => anchor.slug),
             ),
-            anchorUuids: record.foundry?.note?.anchors,
-            docAnchorUuids: documentation?.foundry?.note?.anchors,
+            anchorUuids: prepared?.anchorUuids ?? record.foundry?.note?.anchors,
+            docAnchorUuids: prepared?.docAnchorUuids ?? documentation?.foundry?.note?.anchors,
         });
     }
     // Packages this build links *into* but does not publish. Each publishes

package/engine/journals.mjs

@@ -73,6 +73,7 @@ import { reckoningContext } from "./reckoning-markers.mjs";
 import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 import { JOURNAL_TYPES } from "./ids.mjs";
 import { journalHasContent } from "./note-state.mjs";
+import { hasLexicalEntries } from "./lexical-sections.mjs";
 import { draftNoticeFor } from "./draft-notice.mjs";
 import { scanFigures } from "./content-figures.mjs";
 import { separateFootnotes } from "./content-footnotes.mjs";
@@ -760,13 +761,15 @@ export class Journals extends BasePackCompiler {
      * An entry holding only its infobox is empty by this test. The panel is a
      * rendering of `data:` that the content index already carries, so a
      * compendium entry of nothing else tells a reader what the index told them.
+     * A frontmatter dictionary or glossary supplies pages of its own, so it
+     * qualifies before the shared body expansion inserts it.
      *
      * @param {object} fm - The note's frontmatter.
      * @param {string} body - The note body, frontmatter stripped.
      * @returns {boolean} True to skip the note.
      */
     skipNote(fm, body) {
-        return !journalHasContent(body);
+        return !journalHasContent(body) && !hasLexicalEntries(fm);
     }
 
     /**