@heroiclands/package-build 23.7.1 → 23.9.0

package/engine/content-links.mjs

@@ -90,7 +90,7 @@ import {
 import { loadForeignIndexes, noContentIndexPackages } from "./metadata-index.mjs";
 import { frontmatterWikilinks, slugify } from "./web-wikilinks.mjs";
 import { homepageAddresses, isHomepage } from "./homepage.mjs";
-import { parseWikilink, WIKILINK } from "./wikilink-syntax.mjs";
+import { isEventAnchor, parseWikilink, WIKILINK } from "./wikilink-syntax.mjs";
 import { readQualifier } from "./wikilinks.mjs";
 
 /**
@@ -243,7 +243,10 @@ export function buildLinkIndex(
         // same headings — the disagreement the anchor half removes.
         anchors.set(
             note,
-            new Set((record.anchors ?? []).filter((a) => a.kind === "prose").map((a) => a.slug)),
+            new Set([
+                ...(record.anchors ?? []).filter((a) => a.kind === "prose").map((a) => a.slug),
+                ...(sqlTables?.get(absPath)?.anchors ?? []).map((a) => a.slug),
+            ]),
         );
         eventAnchorsOf.set(
             note,
@@ -331,7 +334,13 @@ export function buildLinkIndex(
      */
     function expandedBody(note) {
         const body = note.body;
-        if (!/^[ \t]*(?:`{3,}|~{3,})[ \t]*(?:sql|pagelist)\b/im.test(body)) return body;
+        const prepared = sqlTables?.get(note.file);
+        if (
+            !prepared?.generated &&
+            !prepared?.lexical?.length &&
+            !/^[ \t]*(?:`{3,}|~{3,})[ \t]*(?:sql|pagelist)\b/im.test(body)
+        )
+            return body;
         return expandContentTables(body, {
             source: note.file,
             // A generated link is checked like an authored one, so both
@@ -940,18 +949,37 @@ export function auditLinks(index) {
     for (const note of notes) {
         for (const { target, rawTarget, anchor, text, occurrence, labelled } of linksOf(note)) {
             if (!anchor || !labelled) continue;
-            const dest = target ? resolve(target) : note;
-            // An unresolvable target is reported by the pass below; its anchor
-            // has nothing to be checked against. Neither has a file: an asset
-            // resolves but has no body, so it declares the empty set of anchors
-            // and every `#section` on one is dead.
-            if (!dest) continue;
-            if (!(anchors.get(dest) ?? new Set()).has(slugify(anchor))) {
+            const local = target ? resolve(target) : note;
+            const foreign = !local && target ? manifestHit(target) : null;
+            // An unresolved address is reported below. A foreign sheet opens
+            // its system document, so only the readable note view names prose
+            // sections. A public note's GM target is an audience refusal below.
+            if (!local) {
+                if (!foreign || (foreign.gm && !isGmNote(note.fm))) continue;
+                const qualified = readQualifier(
+                    target,
+                    index.types,
+                    index.packages,
+                    index.noIndexPackages,
+                );
+                if (qualified?.system !== NOTE_SYSTEM) continue;
+            }
+            const dest = local ?? foreign;
+            const slug = local ? slugify(anchor) : anchor;
+            const event =
+                local ?
+                    (index.eventAnchorsOf?.get(local) ?? new Set()).has(anchor)
+                :   isEventAnchor(foreign, anchor);
+            // Fetched note anchors are the publisher's declaration, independent
+            // of a site URL or a Foundry UUID. An asset has no body and therefore
+            // declares no sections; an absent foreign anchor list does too.
+            const declared =
+                local ?
+                    (anchors.get(local) ?? new Set()).has(slug)
+                :   foreign.noteAnchors?.some((one) => one.slug === anchor && one.kind === "prose");
+            if (!declared || (!local && event)) {
                 deadAnchors.push({
-                    reason:
-                        (index.eventAnchorsOf?.get(dest) ?? new Set()).has(anchor) ?
-                            "event-anchor"
-                        :   "unknown-anchor",
+                    reason: event ? "event-anchor" : "unknown-anchor",
                     note,
                     link: `${rawTarget}#${anchor}`,
                     // The two the shared `unknown-anchor` wording reads, in the
@@ -960,7 +988,7 @@ export function auditLinks(index) {
                     // declare. Carrying them is what lets one sentence serve
                     // the checker and the build.
                     target: rawTarget,
-                    anchor: slugify(anchor),
+                    anchor: slug,
                     dest,
                     text,
                     occurrence,

package/engine/content-poetry.mjs

@@ -71,9 +71,12 @@ export function poetryMarkdown(body) {
         .join("\n\n");
 }
 
+import MarkdownIt from "markdown-it";
 import { slugify } from "./content-slug.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
+const structureParser = new MarkdownIt({ html: true });
+
 /** Read poetry code fences; start/end are inclusive zero-based source lines.
  * @param {string} source - Authored Markdown.
  */
@@ -81,8 +84,14 @@ export function scanPoetry(source) {
     const lines = String(source ?? "").split("\n"),
         blocks = [],
         errors = [];
+    const literalLines = new Set();
+    for (const token of structureParser.parse(String(source ?? ""), {})) {
+        if (!token.map || !["blockquote_open", "html_block"].includes(token.type)) continue;
+        for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);
+    }
     let opening = null;
     for (let i = 0; i < lines.length; i++) {
+        if (literalLines.has(i)) continue;
         const match = /^ *(`{3,}|~{3,})(.*)$/.exec(lines[i]);
         if (opening) {
             if (

package/engine/content-tables.mjs

@@ -14,6 +14,7 @@
 import { FENCE_LINE } from "./code-fences.mjs";
 import { PAGE_LIST_LANGUAGE } from "./page-lists.mjs";
 import { appendGeneratedSections } from "./generated-sections.mjs";
+import { insertLexicalSections } from "./lexical-sections.mjs";
 
 /**
  * Replace prepared SQL fences and page lists with Markdown while retaining
@@ -29,7 +30,8 @@ import { appendGeneratedSections } from "./generated-sections.mjs";
  *   Prepared results.
  * A note's generated sections — see {@link module:engine/generated-sections} —
  * are appended to the body first, from the `generated` text the preparation
- * set on its results, and expanded with it.
+ * set on its results, and expanded with it. Automatic lexical lists, carried
+ * on `lexical`, then fill their authored sections or append a new section.
  *
  * @returns {{markdown: string, errors: object[], warnings: object[], lineMap: object[],
  *   generatedFrom?: number}} `generatedFrom` is the 0-based line of the
@@ -148,10 +150,12 @@ export function expandContentTables(markdown, { source = "", sqlTables, pageList
         i = close;
     }
     return {
-        markdown: out.join("\n"),
+        ...insertLexicalSections(out.join("\n"), sqlTables?.lexical, {
+            authored,
+            lineMap,
+            generatedFrom,
+        }),
         errors,
         warnings,
-        lineMap,
-        ...(generatedFrom === undefined ? {} : { generatedFrom }),
     };
 }

package/engine/culture-reach.mjs

@@ -15,17 +15,14 @@
  * Which terms reach a culture or an affiliation, and whether an affiliation
  * reaches a culture at all.
  *
- * A culture's terms are the words of its language, and the ranks, offices and
- * language words of every affiliation that reaches it — through its own
- * `data.culture`, the one the index resolves for it, or the culture of an
- * affiliation above it through `data.parents` —
- * each affiliation's language being the one its glossary resolves to
- * ({@link module:engine/glossary-language}). An affiliation's terms are its own
- * ranks and offices and the words of that language. A language's words include
- * the words it inherits through `data.family`, and a word is a term only where
+ * A culture can name the ranks and offices of every affiliation that reaches
+ * it through `data.culture` or `data.parents`. An affiliation can name its own
+ * ranks and offices. Each glossary entry can also name a word of its resolved
+ * language ({@link module:engine/glossary-language}). A language's words include
+ * those it inherits through `data.family`, and a word is a term only where
  * its class's base is a glossary base. The `dictionary` relation
- * ({@link module:engine/dictionary-rows}) names a glossary entry's term from
- * the same reach.
+ * ({@link module:engine/dictionary-rows}) uses the same resolved-language and
+ * governance sources.
  *
  * **An affiliation that reaches no culture is a warning**, at its `type`, in a
  * tree that describes peoples, which is a tree holding at least one culture
@@ -42,7 +39,7 @@ import { AddressLink } from "./address-values.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
 import { parseWordClass, WORD_CLASS_BASES } from "./word-classes.mjs";
-import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
+import { glossSenses, LANGUAGE_SUBTYPE } from "./word-terms.mjs";
 
 /** The bases whose words are glossary terms. */
 const GLOSSARY_BASES = new Set(
@@ -189,6 +186,11 @@ export function entryLanguage(index, note, entry) {
  * @property {Map<string, Map<string, string[]>>} terms - Each culture's and
  *   affiliation's terms by NFC name, each with the sense texts its sources
  *   give it.
+ * @property {Map<string, Map<string, string[]>>} governance - The ranks and
+ *   offices each owner can name.
+ * @property {Map<string, Array<{form: string, gloss: unknown}>>} words - Each
+ *   language's dictionary words.
+ * @property {Map<string, string|undefined>} families - Each language's parent.
  */
 
 /** @type {WeakMap<object, GlossaryCorpus>} */
@@ -239,6 +241,23 @@ function reachedCultures(index, note) {
     return [...out];
 }
 
+/** Add the nearest dictionary definition of each form in a language's lineage. */
+function addLanguageWords(terms, key, language, words, families) {
+    const seen = new Set();
+    const forms = new Set();
+    for (let current = language; current && !seen.has(current); current = families.get(current)) {
+        seen.add(current);
+        for (const word of words.get(current) ?? []) {
+            const form = glossaryName(word.form);
+            if (forms.has(form)) continue;
+            forms.add(form);
+            const senses = glossSenses(word.gloss);
+            if (!senses.length) addTerm(terms, key, form, undefined);
+            for (const sense of senses) addTerm(terms, key, form, sense);
+        }
+    }
+}
+
 /**
  * The glossary corpus of an index.
  *
@@ -257,18 +276,7 @@ export function glossaryCorpus(index) {
             if (key) families.set(key, addressKeyOf(dataOf(note).family, index, "skill"));
         }
     const terms = new Map();
-    // A language's words include those it inherits through `data.family`.
-    const addWords = (key, language) => {
-        const seen = new Set();
-        for (
-            let current = language;
-            current && !seen.has(current);
-            current = families.get(current)
-        ) {
-            seen.add(current);
-            for (const word of words.get(current) ?? []) addTerm(terms, key, word.form, word.gloss);
-        }
-    };
+    const governance = new Map();
     for (const note of notes) {
         const culture = isCultureNote(note);
         if (!culture && typeOf(note) !== "affiliation") continue;
@@ -276,18 +284,22 @@ export function glossaryCorpus(index) {
         if (!key) continue;
         if (!terms.has(key)) terms.set(key, new Map());
         const data = dataOf(note);
-        if (culture) {
-            addWords(key, addressKeyOf(data.language, index, "skill"));
-            continue;
-        }
+        addLanguageWords(terms, key, entryLanguage(index, note, undefined), words, families);
+        if (culture) continue;
         addGovernance(terms, key, data);
-        addWords(key, entryLanguage(index, note, undefined));
+        addGovernance(governance, key, data);
         for (const home of reachedCultures(index, note)) {
             addGovernance(terms, home, data);
-            addWords(home, entryLanguage(index, note, undefined));
+            addGovernance(governance, home, data);
         }
     }
-    const corpus = { describesPeoples: notes.some(isCultureNote), terms };
+    const corpus = {
+        describesPeoples: notes.some(isCultureNote),
+        terms,
+        governance,
+        words,
+        families,
+    };
     CORPUS.set(index, corpus);
     return corpus;
 }
@@ -298,16 +310,31 @@ export function glossaryCorpus(index) {
  *
  * @param {object} index - The link index.
  * @param {object} note - The culture or affiliation note.
+ * @param {object} [entry] - A glossary entry, whose resolved language selects
+ *   its dictionary words. Absent, the note's own language is used.
  * @returns {Map<string, string[]>} The terms; empty for a note no source reaches.
  */
-export function noteTerms(index, note) {
+export function noteTerms(index, note, entry) {
     const key = ownKey(note, index);
-    return (key && glossaryCorpus(index).terms.get(key)) || new Map();
+    const corpus = glossaryCorpus(index);
+    if (!entry) return (key && corpus.terms.get(key)) || new Map();
+    const own = new Map(
+        [...(corpus.governance.get(key) ?? [])].map(([name, senses]) => [name, [...senses]]),
+    );
+    addLanguageWords(
+        new Map([[key, own]]),
+        key,
+        entryLanguage(index, note, entry),
+        corpus.words,
+        corpus.families,
+    );
+    return own;
 }
 
 /**
  * Warn of an affiliation that reaches no culture, its own or one it inherits,
- * in a tree that describes peoples.
+ * in a tree that describes peoples. Its ranks and offices then have no
+ * culture associations for term queries.
  *
  * @param {object} note - An `affiliation` note.
  * @param {{index?: object}} [context]
@@ -323,7 +350,7 @@ export function checkAffiliationReach(note, { index } = {}) {
             severity: "warning",
             message:
                 "this affiliation reaches no culture, its own or one inherited through " +
-                "`data.parents`, so its ranks, offices and language enter no culture's glossary; " +
+                "`data.parents`, so its ranks and offices have no culture associations for term queries; " +
                 "state `data.culture`",
         },
     ];

package/engine/data-keys.mjs

@@ -70,6 +70,8 @@ import { nearest } from "./near-miss.mjs";
  *   every surface shows it exactly as written, never recased.
  * @property {string} shape - The shape in words, for a finding and the reference.
  * @property {boolean} [required] - The key must be stated, with a value.
+ * @property {boolean} [allowEmpty] - A required string may be empty where
+ *   empty text is a stated value.
  * @property {boolean} [nullable] - An explicit `null` states the key, for a
  *   required key whose null has a meaning of its own.
  * @property {string} [label] - The infobox row label, where humanising the key
@@ -234,7 +236,7 @@ export function pathLabel(path) {
 function stated(value, spec) {
     if (value === undefined) return false;
     if (value === null) return Boolean(spec.nullable);
-    if (typeof value === "string") return value.trim() !== "";
+    if (typeof value === "string") return Boolean(spec.allowEmpty) || value.trim() !== "";
     return true;
 }
 

package/engine/diagnostics.mjs

@@ -249,15 +249,20 @@ export function positionInFrontmatter(raw, key, value = undefined, { topLevel =
  *   {@link positionInFrontmatter}.
  * @param {boolean} [options.topLevel=false] - Require the key at column 1, so
  *   an identically named nested key cannot answer for it.
+ * @param {string} [options.raw] - Source text already read by the caller.
  * @returns {{line?: number, column?: number}|undefined} Spreadable position
  *   fields, dropped rather than guessed when the file cannot be read or the key
  *   cannot be found — as `formatDiagnostic` requires.
  */
-export function locateFrontmatterKey(absPath, key, value = undefined, { topLevel = false } = {}) {
-    if (!absPath) return undefined;
-    let raw;
+export function locateFrontmatterKey(
+    absPath,
+    key,
+    value = undefined,
+    { topLevel = false, raw } = {},
+) {
+    if (!absPath && raw === undefined) return undefined;
     try {
-        raw = fs.readFileSync(absPath, "utf8");
+        raw ??= fs.readFileSync(absPath, "utf8");
     } catch {
         return undefined;
     }
@@ -306,6 +311,9 @@ export function positionOfLiteral(text, needle, occurrence = 1) {
     };
 }
 
+/** The most recently located text; retaining one document bounds memory. */
+let locatedYaml;
+
 /**
  * Where a **key or value in a YAML document** sits, addressed by its path.
  *
@@ -315,11 +323,10 @@ export function positionOfLiteral(text, needle, occurrence = 1) {
  * first occurrence is routinely not the one the finding is about — which is the
  * one thing the located form exists to prevent.
  *
- * A path resolves the exact node instead. The document is re-parsed here rather
- * than threaded from the loader because the loader returns plain data: `yaml`
- * discards ranges once a document is materialised, and carrying a parallel
- * position tree through configuration resolution would be a second
- * representation of the same file to keep in step.
+ * A path resolves the exact node. The most recently located text retains its
+ * document and line counter, so several findings in one note share a parse.
+ * A different text replaces that entry, including an edited copy of the same
+ * file. The loader returns plain data without source ranges.
  *
  * Every failure — unparseable text, an `.mjs` configuration, a path that
  * resolves to nothing — yields `{}`, so a caller spreads the result and the
@@ -348,9 +355,15 @@ export function positionOfYamlPath(text, keyPath, { key = false } = {}) {
     if (!Array.isArray(keyPath) || keyPath.length === 0) return {};
 
     let node;
-    const counter = new LineCounter();
+    let counter;
     try {
-        const doc = YAML.parseDocument(text, { lineCounter: counter });
+        if (locatedYaml?.text !== text) {
+            const lineCounter = new LineCounter();
+            const doc = YAML.parseDocument(text, { lineCounter });
+            locatedYaml = { text, doc, counter: lineCounter };
+        }
+        const { doc } = locatedYaml;
+        counter = locatedYaml.counter;
         // `keepScalar` returns the Scalar node rather than its value, which is
         // the only form carrying a range.
         node = doc.getIn(keyPath, true);