@heroiclands/package-build 23.7.1 → 23.9.0

package/engine/sql-tables.mjs

@@ -26,7 +26,9 @@
  * @module
  */
 
-import { parseAddress, renderAddress, isAddressTuple } from "./address.mjs";
+import { parseAddress, readCanonicalKey, renderAddress, isAddressTuple } from "./address.mjs";
+import { collectAnchors } from "./anchors.mjs";
+import { expandContentTables } from "./content-tables.mjs";
 import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
 import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs";
 import { EVENT_COLUMNS, EVENT_SORT_COLUMNS, eventRows } from "./event-rows.mjs";
@@ -45,8 +47,10 @@ import {
 } from "./word-rows.mjs";
 import { DICTIONARY_COLUMNS, TERM_COLUMNS, dictionaryAndTermRows } from "./dictionary-rows.mjs";
 import { LANGUAGE_COLUMN_TYPES, LANGUAGE_RELATIONS } from "./language-rows.mjs";
+import { VERB_PERSON_FIELDS } from "./language-terms.mjs";
 import { renderDictionary, renderGlossary } from "./dictionary-layout.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
+import { lexicalSectionsFor } from "./lexical-sections.mjs";
 import { eventViewSections } from "./event-views.mjs";
 import { appendGeneratedSections, joinSections } from "./generated-sections.mjs";
 import fs from "node:fs";
@@ -60,7 +64,7 @@ import { MARKET_CLASSES } from "./market-class.mjs";
 import { parseMarkdownFile } from "./helpers.mjs";
 import { sqlQueriesInMarkdown } from "./markdown-expressions.mjs";
 // The record accessors only — see `engine/index-records.mjs`.
-import { isNoteRecord, noteFile, sortKeysDeep } from "./index-records.mjs";
+import { authoredFrontmatter, isNoteRecord, noteFile, sortKeysDeep } from "./index-records.mjs";
 
 /** Rendered in a cell whose value is absent. */
 const EMPTY_CELL = "—";
@@ -261,16 +265,12 @@ export async function openNotesDatabase(
     const base = dir ?? fs.mkdtempSync(path.join(os.tmpdir(), "content-sql-"));
     fs.mkdirSync(base, { recursive: true });
     const jsonl = path.join(base, "notes.jsonl");
-    fs.writeFileSync(
-        jsonl,
-        records.map((record) => JSON.stringify(sortKeysDeep(encodeAddresses(record)))).join("\n"),
-    );
+    const encoded = records.map((record) => encodeAddresses(record));
 
     const instance = await DuckDBInstance.create(":memory:");
     const connection = await instance.connect();
     await connection.run("SET threads=1");
-    await createRelations(connection, jsonl, "", audience);
-    const encoded = records.map((record) => encodeAddresses(record));
+    await createRelations(connection, jsonl, encoded, "", audience);
     await createEventRelation(connection, path.join(base, "events.jsonl"), encoded, "", audience);
     await createWordRelations(connection, path.join(base, "notes"), encoded, "", audience);
 
@@ -293,8 +293,7 @@ export async function openNotesDatabase(
             .split("\n")
             .filter((line) => line.trim())
             .map((line) => flattenPublishedAddresses(JSON.parse(line)));
-        fs.writeFileSync(flat, depRecords.map((record) => JSON.stringify(record)).join("\n"));
-        await createRelations(connection, flat, `${schema}.`, audience);
+        await createRelations(connection, flat, depRecords, `${schema}.`, audience);
         await createEventRelation(
             connection,
             flat.replace(/\.jsonl$/, "-events.jsonl"),
@@ -462,12 +461,27 @@ const WITH_STUBS_SCHEMA = "__with_stubs";
  * of the ladder falls back to a constant where its column is absent.
  *
  * @param {object} connection - An open DuckDB connection.
- * @param {string} file - The JSONL to read.
+ * @param {string} file - Where to write the audience's JSONL.
+ * @param {object[]} records - Complete index records, every Address a string.
  * @param {string} [prefix] - A schema to qualify the view names with.
+ * @param {"all"|"public"} [audience] - Whether to leave out GM notes.
  * @returns {Promise<void>}
  */
-async function createRelations(connection, file, prefix = "", audience = "all") {
-    const read = readJsonAuto(file);
+async function createRelations(connection, file, records, prefix = "", audience = "all") {
+    // Every record contributes its schema; only visible records contribute rows.
+    fs.writeFileSync(
+        file,
+        records
+            .map((record) =>
+                JSON.stringify({
+                    record: sortKeysDeep(record),
+                    visible: audience !== "public" || !isGmNote(record),
+                }),
+            )
+            .join("\n"),
+    );
+    const source = readJsonAuto(file);
+    const read = records.length ? `SELECT record.* FROM (${source}) WHERE visible` : source;
     const described = await connection.runAndReadAll(`DESCRIBE ${read}`);
     const columns = new Set(described.getRowObjects().map((row) => String(row.column_name)));
     // A row with no address is a stub. With no address column anywhere, every
@@ -481,16 +495,11 @@ async function createRelations(connection, file, prefix = "", audience = "all")
             "COALESCE(list_contains(TRY_CAST(tags AS VARCHAR[]), 'draft'), false) " +
             "OR COALESCE(TRY_CAST(tags AS VARCHAR) = 'draft', false)"
         :   "false";
-    const visible =
-        audience === "public" && columns.has("tags") ?
-            "NOT (COALESCE(list_contains(TRY_CAST(tags AS VARCHAR[]), 'gm'), false) " +
-            "OR COALESCE(TRY_CAST(tags AS VARCHAR) = 'gm', false))"
-        :   "true";
     await createTableFromFile(
         connection,
         `${prefix}entries`,
         `SELECT *, CASE WHEN ${stub} THEN 'stub' WHEN ${draft} THEN 'draft' ` +
-            `ELSE 'full' END AS state FROM (${read}) WHERE ${visible}`,
+            `ELSE 'full' END AS state FROM (${read})`,
     );
     await connection.run(
         `CREATE VIEW ${prefix}notes AS SELECT * FROM ${prefix}entries WHERE state <> 'stub'`,
@@ -617,20 +626,68 @@ async function createWordRelations(connection, stem, records, prefix, audience)
         LINEAGE_COLUMNS,
     );
     const { dictionary, terms } = dictionaryAndTermRows(visible, records);
-    await createRowRelation(
-        connection,
-        `${stem}-dictionary.jsonl`,
-        dictionary,
-        `${prefix}dictionary`,
-        DICTIONARY_COLUMNS,
-    );
-    await createRowRelation(
-        connection,
-        `${stem}-terms.jsonl`,
-        terms,
-        `${prefix}terms`,
-        TERM_COLUMNS,
-    );
+    const dictionaryTypes = {
+        etymology:
+            "STRUCT(kind VARCHAR, language VARCHAR, language_tag VARCHAR, form VARCHAR, " +
+            "parts STRUCT(form VARCHAR, gloss VARCHAR)[], root VARCHAR, frame VARCHAR)",
+        senses: "STRUCT(text VARCHAR, bodies VARCHAR[])[]",
+        usage: "VARCHAR[]",
+        depth: "BIGINT",
+        verbs: `STRUCT(invariant BOOLEAN, persons STRUCT(${VERB_PERSON_FIELDS.map((person) => `"${person.name}" VARCHAR`).join(", ")}))`,
+    };
+    const dictionaryFile = `${stem}-dictionary.jsonl`;
+    if (dictionary.length) {
+        // Only the dictionary's declared schema: optional patterns must not
+        // change its nested/list types when a corpus has no stated grammar.
+        fs.writeFileSync(dictionaryFile, dictionary.map((row) => JSON.stringify(row)).join("\n"));
+        const columns = DICTIONARY_COLUMNS.map(
+            (column) =>
+                `CAST("${column}" AS ${dictionaryTypes[column] ?? "VARCHAR"}) AS "${column}"`,
+        );
+        await createTableFromFile(
+            connection,
+            `${prefix}dictionary`,
+            `SELECT ${columns.join(", ")} FROM (${readJsonAuto(dictionaryFile)})`,
+        );
+    } else {
+        await createRowRelation(
+            connection,
+            dictionaryFile,
+            dictionary,
+            `${prefix}dictionary`,
+            DICTIONARY_COLUMNS,
+            dictionaryTypes,
+        );
+    }
+    const termTypes = {
+        senses: "STRUCT(text VARCHAR, bodies VARCHAR[])[]",
+        usage: "VARCHAR[]",
+        common: "BOOLEAN",
+        origins: "VARCHAR[]",
+        cultures: "VARCHAR[]",
+    };
+    const termsFile = `${stem}-terms.jsonl`;
+    if (terms.length) {
+        // Terms retain declared types even when every value of a column is null.
+        fs.writeFileSync(termsFile, terms.map((row) => JSON.stringify(row)).join("\n"));
+        const columns = TERM_COLUMNS.map(
+            (column) => `CAST("${column}" AS ${termTypes[column] ?? "VARCHAR"}) AS "${column}"`,
+        );
+        await createTableFromFile(
+            connection,
+            `${prefix}terms`,
+            `SELECT ${columns.join(", ")} FROM (${readJsonAuto(termsFile)})`,
+        );
+    } else {
+        await createRowRelation(
+            connection,
+            termsFile,
+            terms,
+            `${prefix}terms`,
+            TERM_COLUMNS,
+            termTypes,
+        );
+    }
     for (const [name, rowsOf, columns] of LANGUAGE_RELATIONS)
         await createRowRelation(
             connection,
@@ -879,8 +936,9 @@ export function renderSqlTable(
  * its own table and not the whole build's report.
  *
  * @param {object} db - From {@link openNotesDatabase}.
- * @param {Array<{source: string, markdown: string}>} sources - The bodies to
- *   scan.
+ * @param {Array<{source: string, markdown: string, frontmatter?: object, authoredSqlBlocks?: number}>} sources -
+ *   The bodies to scan. `joinGeneratedSections` records the number of authored
+ *   fences; following generated event fences need no stub comparison.
  * @param {object} [opts]
  * @param {(ref: string) => boolean} [opts.linkable] - Passed to
  *   {@link renderSqlTable}.
@@ -904,26 +962,33 @@ export async function prepareSqlTables(db, sources, { linkable, records, pageLan
     const prepared = new Map();
     if (records) prepared.pageLists = preparePageLists(records, sources);
     // The corpus does not change while a preparation runs, so a query written
-    // twice has one answer. Each use gets its own copy, because a caller
-    // rewrites the rows it is handed.
+    // twice has one answer in each stub context. The normal result and the
+    // inclusive comparison occupy separate fields of the same cache entry.
+    // Each result use gets a copy because a caller rewrites the rows.
     const answers = new Map();
     const reader = {
         ...db,
         async query(sql) {
-            if (!answers.has(sql)) answers.set(sql, await db.query(sql));
-            return structuredClone(answers.get(sql));
+            if (!answers.has(sql)) answers.set(sql, { result: await db.query(sql) });
+            return structuredClone(answers.get(sql).result);
+        },
+        async stubsExcluded(sql, rows) {
+            const answer = answers.get(sql);
+            if (!Object.hasOwn(answer, "excluded"))
+                answer.excluded = await db.stubsExcluded?.(sql, rows);
+            return answer.excluded;
         },
     };
     let labels;
     const labelOf = (address) => labels.get(address);
     const languageOf =
         pageLanguage ?? ((_source, frontmatter) => frontmatterLanguage(frontmatter, db));
-    for (const { source, markdown, frontmatter } of sources) {
+    for (const { source, markdown, frontmatter, authoredSqlBlocks = Infinity } of sources) {
         const blocks = findSqlBlocks(markdown);
         if (!blocks.length) continue;
         const forNote = [];
         prepared.set(source, forNote);
-        for (const block of blocks) {
+        for (const [ordinal, block] of blocks.entries()) {
             try {
                 if (block.problems.length) throw new Error(block.problems.join("; "));
                 const result = await runSqlQuery(reader, block.query);
@@ -945,6 +1010,20 @@ export async function prepareSqlTables(db, sources, { linkable, records, pageLan
                                 labelOf,
                                 showKey: block.showKey,
                                 pageLanguage: languageOf(source, frontmatter),
+                                pageOwner:
+                                    (
+                                        typeof frontmatter?.type === "string" &&
+                                        typeof frontmatter.shortcode === "string" &&
+                                        db.addressContext?.package
+                                    ) ?
+                                        renderAddress({
+                                            package: db.addressContext.package,
+                                            system: "note",
+                                            type: frontmatter.type,
+                                            shortcode: frontmatter.shortcode,
+                                        })
+                                    :   undefined,
+                                entryAnchors: false,
                             })
                         :   renderSqlTable(result, options),
                     rows: result.rows.length,
@@ -952,7 +1031,12 @@ export async function prepareSqlTables(db, sources, { linkable, records, pageLan
                     // relation, so a fence that has not adopted stubs says so
                     // rather than quietly listing fewer settlements than the
                     // region has.
-                    stubsExcluded: await db.stubsExcluded?.(block.query, result.rows.length),
+                    // Generated event views read entries and events, whose
+                    // meaning is identical in both stub contexts.
+                    stubsExcluded:
+                        ordinal >= authoredSqlBlocks ? 0 : (
+                            await reader.stubsExcluded(block.query, result.rows.length)
+                        ),
                     allowEmpty: block.allowEmpty,
                 });
             } catch (err) {
@@ -1095,8 +1179,11 @@ export async function prepareInlineSqlExpressions(db, sources) {
  * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
  *   lists, from an earlier call over the same records, which are not derived
  *   again.
+ * @param {object[]} [opts.all=records] - Complete records for lexical lineage
+ *   traversal through providers outside the surface's audience.
  * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
- *   derived: Map<string, Map<string, string>>}>} Note file to its sections,
+ *   derived: Map<string, Map<string, string>>,
+ *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}>} Note file to its sections,
  *   joined in order; the files whose sections hold an event view's fence; and
  *   the derived lists alone.
  */
@@ -1104,7 +1191,7 @@ export async function generatedSectionsFor(
     db,
     records,
     contentBase,
-    { only, foreignIndex, config, derived: given } = {},
+    { only, foreignIndex, config, derived: given, all = records } = {},
 ) {
     const notes = records.filter((record) => isNoteRecord(record));
     const fileOf = (record) => noteFile(contentBase, record);
@@ -1122,7 +1209,26 @@ export async function generatedSectionsFor(
     const sections = new Map();
     for (const file of new Set([...derived.keys(), ...views.keys()]))
         sections.set(file, joinSections([derived.get(file), views.get(file)]));
-    return { sections, views: new Set(views.keys()), derived };
+    // Automatic sections follow their source's audience even in a Foundry
+    // corpus containing both public and private packs. Explicit SQL keeps
+    // the database audience the caller requested.
+    const publicRecords = records.filter((record) => !isGmNote(record));
+    const publicOwners = lexicalSectionsFor(publicRecords, all);
+    const allOwners =
+        publicRecords.length === records.length ? publicOwners : lexicalSectionsFor(records, all);
+    const lexical = new Map();
+    for (const note of notes) {
+        const owners = isGmNote(note) ? allOwners : publicOwners;
+        const key = renderAddress({
+            package: note.package,
+            system: "note",
+            type: note.type,
+            shortcode: note.shortcode,
+        });
+        if (owners.has(key) && (only === undefined || fileOf(note) === only))
+            lexical.set(fileOf(note), owners.get(key));
+    }
+    return { sections, views: new Set(views.keys()), derived, lexical };
 }
 
 /**
@@ -1138,7 +1244,7 @@ export async function generatedSectionsFor(
  *
  * @param {{sections: Map<string, string>, views: Set<string>}} generated -
  *   From {@link generatedSectionsFor}.
- * @param {Array<{source: string, markdown: string, frontmatter?: object}>} sources -
+ * @param {Array<{source: string, markdown: string, frontmatter?: object, authoredSqlBlocks?: number}>} sources -
  *   The bodies to answer, extended in place.
  * @param {Map<string, {body: string, frontmatter: object|null}>} [parsed] -
  *   Notes already parsed, keyed by file; a note absent from it is read.
@@ -1148,6 +1254,7 @@ export function joinGeneratedSections(generated, sources, parsed) {
     for (const [absPath, text] of generated.sections) {
         const source = sources.find((one) => one.source === absPath);
         if (source) {
+            source.authoredSqlBlocks ??= findSqlBlocks(source.markdown).length;
             source.markdown = appendGeneratedSections(source.markdown, text);
             continue;
         }
@@ -1157,6 +1264,7 @@ export function joinGeneratedSections(generated, sources, parsed) {
             source: absPath,
             markdown: appendGeneratedSections(body, text),
             frontmatter,
+            authoredSqlBlocks: findSqlBlocks(body).length,
         });
     }
 }
@@ -1167,7 +1275,7 @@ export function joinGeneratedSections(generated, sources, parsed) {
  * empty set carrying them.
  *
  * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
- * @param {{sections: Map<string, string>}} generated - From
+ * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}} generated - From
  *   {@link generatedSectionsFor}.
  * @returns {void}
  */
@@ -1177,6 +1285,51 @@ export function attachGeneratedSections(prepared, generated) {
         if (!results) prepared.set(absPath, (results = []));
         results.generated = text;
     }
+    for (const [absPath, sections] of generated.lexical ?? []) {
+        let results = prepared.get(absPath);
+        if (!results) prepared.set(absPath, (results = []));
+        results.lexical = sections;
+    }
+}
+
+/**
+ * Index the anchors the prepared bodies actually emit, including anchors in
+ * SQL results. Foundry maps use the same expanded body the compiler splits.
+ *
+ * @param {Map<string, object[]>} prepared - The prepared directives.
+ * @param {object[]} records - The visible content-index records.
+ * @param {string} contentBase - Root of the content tree.
+ * @param {Map<string, object>} parsed - Notes already parsed.
+ * @param {object} [config] - The resolved build configuration.
+ * @returns {Promise<void>}
+ */
+async function attachPreparedAnchors(prepared, records, contentBase, parsed, config) {
+    const { entriesForNote, foundryIdentities } = await import("./foundry-entries.mjs");
+    const identities = config ? foundryIdentities(config) : undefined;
+    for (const record of records) {
+        if (!isNoteRecord(record)) continue;
+        const file = noteFile(contentBase, record);
+        const results = prepared.get(file);
+        if (!results) continue;
+        const { body } = parsed.get(file) ?? parseMarkdownFile(file);
+        const expanded = expandContentTables(body, {
+            source: file,
+            sqlTables: results,
+            pageLists: prepared.pageLists?.get(file),
+        }).markdown;
+        results.anchors = collectAnchors(expanded);
+        if (!identities || !record.address?.slug) continue;
+        const frontmatter = authoredFrontmatter(record);
+        const entries = entriesForNote(
+            frontmatter,
+            frontmatter.name?.full ?? record.file.name,
+            record.address.slug,
+            expanded,
+            identities,
+        );
+        results.anchorUuids = entries[0]?.anchors;
+        results.docAnchorUuids = entries[1]?.anchors;
+    }
 }
 
 /**
@@ -1290,9 +1443,9 @@ export async function prepareTreeSqlTables(
     // uninitialised for whichever module the runtime happened to load first.
     const { indexRecordsFor } = await import("./content-index.mjs");
     const notes = parsed ?? new Map();
-    const indexRecords = (
-        records ?? indexRecordsFor({ contentBase, config, skipDirectories, parsed: notes })
-    ).filter((record) => audience !== "public" || !isGmNote(record));
+    const allRecords =
+        records ?? indexRecordsFor({ contentBase, config, skipDirectories, parsed: notes });
+    const indexRecords = allRecords.filter((record) => audience !== "public" || !isGmNote(record));
 
     // Which notes carry a directive, discovered over the same corpus every
     // other pass reads rather than over a walk of this one's own. The
@@ -1339,8 +1492,10 @@ export async function prepareTreeSqlTables(
     const derivedOnly = await generatedSectionsFor(undefined, indexRecords, contentBase, {
         foreignIndex: foreign,
         config,
+        all: allRecords,
     });
-    if (!sources.length && !hasEvents && !derivedOnly.sections.size) return undefined;
+    if (!sources.length && !hasEvents && !derivedOnly.sections.size && !derivedOnly.lexical.size)
+        return undefined;
 
     // A page list is a filter over the records, so it needs no database. A tree
     // whose only corpus-reading directive is one therefore opens none — which
@@ -1359,6 +1514,7 @@ export async function prepareTreeSqlTables(
         pageOnly.inline = new Map();
         pageOnly.pageLists = preparePageLists(indexRecords, sources);
         attachGeneratedSections(pageOnly, derivedOnly);
+        await attachPreparedAnchors(pageOnly, indexRecords, contentBase, notes, config);
         return pageOnly;
     }
     // A cell links only where the address it would emit resolves, so a table
@@ -1373,7 +1529,11 @@ export async function prepareTreeSqlTables(
             .filter((record) => !record.documents)
             .map((record) => record.documentation ?? record.address?.canonical)
             .map((target) => target && encodeAddresses(target))
-            .filter(Boolean),
+            .filter(Boolean)
+            .flatMap((target) => [
+                target,
+                renderAddress({ ...readCanonicalKey(target), system: "note" }),
+            ]),
     );
     // Each declared dependency's published index, attached as its own schema so
     // a table can read `FROM <package>.notes`. Imported here for the
@@ -1382,13 +1542,14 @@ export async function prepareTreeSqlTables(
     // been fetched already fails earlier with a message naming the fetch.
     const db =
         database ??
-        (await openNotesDatabase(indexRecords, {
+        (await openNotesDatabase(allRecords, {
             dependencies: await cachedDependencies(config),
             audience,
         }));
     try {
         const generated = await generatedSectionsFor(db, indexRecords, contentBase, {
             derived: derivedOnly.derived,
+            all: allRecords,
         });
         joinGeneratedSections(generated, sources, notes);
         const prepared = await prepareSqlTables(db, sources, {
@@ -1398,8 +1559,81 @@ export async function prepareTreeSqlTables(
         });
         prepared.inline = await prepareInlineSqlExpressions(db, sources);
         attachGeneratedSections(prepared, generated);
+        await attachPreparedAnchors(prepared, indexRecords, contentBase, notes, config);
         return prepared;
     } finally {
         if (!database) await db.close();
     }
 }
+
+/**
+ * Prepare authored link-check tables in each source note's audience. Public
+ * sources share one public database; GM sources share one complete database.
+ * Complete records remain available for authored-link checks.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {object} [opts.config] - Resolved configuration.
+ * @param {readonly string[]} [opts.skipDirectories] - The walk's scope.
+ * @param {object[]} [opts.records] - Complete index records already derived.
+ * @param {Map<string, {body: string, frontmatter: object|null}>} [opts.parsed] - Parsed notes.
+ * @param {Map<string, object>} [opts.foreignIndex] - Published dependency indexes.
+ * @returns {Promise<Map<string, object[]>|undefined>} Prepared tables by source.
+ */
+export async function prepareLinkSqlTables(
+    contentBase,
+    { config, skipDirectories, records, parsed, foreignIndex } = {},
+) {
+    const { indexRecordsFor } = await import("./content-index.mjs");
+    const notes = parsed ?? new Map();
+    const allRecords =
+        records ?? indexRecordsFor({ contentBase, config, skipDirectories, parsed: notes });
+    const sources = new Map();
+    const lexicalOwners = lexicalSectionsFor(allRecords);
+    for (const record of allRecords) {
+        if (!isNoteRecord(record)) continue;
+        const file = noteFile(contentBase, record);
+        let note = notes.get(file);
+        if (!note) {
+            note = parseMarkdownFile(file);
+            notes.set(file, note);
+        }
+        const body = note.body ?? "";
+        if (
+            findSqlBlocks(body).length ||
+            findPageListBlocks(body).length ||
+            sqlQueriesInMarkdown(body, note.frontmatter).length ||
+            lexicalOwners.has(
+                renderAddress({
+                    package: record.package,
+                    system: "note",
+                    type: record.type,
+                    shortcode: record.shortcode,
+                }),
+            )
+        )
+            sources.set(file, isGmNote(record) ? "all" : "public");
+    }
+    if (!sources.size) return undefined;
+    const selected = new Map();
+    selected.pageLists = new Map();
+    selected.inline = new Map();
+    for (const audience of new Set(sources.values())) {
+        const prepared = await prepareTreeSqlTables(contentBase, {
+            config,
+            skipDirectories,
+            records: allRecords,
+            parsed: notes,
+            foreignIndex,
+            audience,
+        });
+        for (const [file, sourceAudience] of sources) {
+            if (sourceAudience !== audience) continue;
+            if (prepared?.has(file)) selected.set(file, prepared.get(file));
+            if (prepared?.pageLists?.has(file))
+                selected.pageLists.set(file, prepared.pageLists.get(file));
+            if (prepared?.inline?.has(file)) selected.inline.set(file, prepared.inline.get(file));
+        }
+    }
+    return selected;
+}

package/engine/standings.mjs

@@ -378,17 +378,19 @@ function resolveBody(note, index, body) {
 
 /** Findings about the body an entry names. */
 function bodyFindings(note, body, path, isKey, found) {
-    const at = position(note, path, isKey);
+    const at = () => position(note, path, isKey);
     const written = isAddressTuple(body) ? renderAddress(body) : String(body);
     const label = `\`data.affiliations\`${isKey ? " key" : ""} ${JSON.stringify(written)}`;
     if (found.reason)
-        return [{ ...at, message: `${label} is not a complete Address (${found.reason})` }];
+        return [{ ...at(), message: `${label} is not a complete Address (${found.reason})` }];
     if (found.type)
-        return [{ ...at, message: `\`data.affiliations\` accepts affiliation, not ${found.type}` }];
+        return [
+            { ...at(), message: `\`data.affiliations\` accepts affiliation, not ${found.type}` },
+        ];
     if (found.missing)
         return [
             {
-                ...at,
+                ...at(),
                 message:
                     `\`data.affiliations\` names ${found.address}, which does not resolve ` +
                     "in this package or its declared dependencies",
@@ -438,12 +440,12 @@ function absentRankFindings(note, body, path) {
 function rankFindings(note, standing, body, path, resolved) {
     // Absent, or not a whole number: the inner-key check's finding.
     if (!fitsKind(standing.rank ?? null, "integer")) return [];
-    const at = position(note, [...path, "rank"]);
+    const at = () => position(note, [...path, "rank"]);
     const level = typeof standing.rank === "number" ? standing.rank : Number(standing.rank);
     if (typeof standing.rank !== "number" || !Number.isInteger(level))
         return [
             {
-                ...at,
+                ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body}: \`rank\` must be the level on that body's own ` +
                     `ladder, as a whole number, but reads ${JSON.stringify(standing.rank)}`,
@@ -455,7 +457,7 @@ function rankFindings(note, standing, body, path, resolved) {
     if (!ladder.size)
         return [
             {
-                ...at,
+                ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body} states a rung, and that body ` +
                     "declares no `data.governance.ranks` ladder to hold one",
@@ -464,7 +466,7 @@ function rankFindings(note, standing, body, path, resolved) {
     const levels = [...ladder.keys()].sort((a, b) => a - b);
     return [
         {
-            ...at,
+            ...at(),
             message:
                 `\`data.affiliations\` entry for ${body}: rank ${level} is not a level ` +
                 `${resolved.address} confers; its ladder runs ${levels.join(", ")}`,
@@ -477,11 +479,11 @@ function officeFindings(note, standing, body, path, resolved) {
     // Absent is a membership with no post; a value that is not text is the
     // inner-key check's finding.
     if (typeof standing.office !== "string") return [];
-    const at = position(note, [...path, "office"]);
+    const at = () => position(note, [...path, "office"]);
     if (!standing.office.trim())
         return [
             {
-                ...at,
+                ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body}: \`office\` must name a post from its ` +
                     `\`governance.offices\`, but reads ${JSON.stringify(standing.office)}`,
@@ -493,7 +495,7 @@ function officeFindings(note, standing, body, path, resolved) {
     if (!roster.size)
         return [
             {
-                ...at,
+                ...at(),
                 message:
                     `\`data.affiliations\` entry for ${body} names an office, and that body ` +
                     `${resolved.address} declares no \`data.governance.offices\` to hold one`,
@@ -501,7 +503,7 @@ function officeFindings(note, standing, body, path, resolved) {
         ];
     return [
         {
-            ...at,
+            ...at(),
             message:
                 `\`data.affiliations\` entry for ${body}: office ${JSON.stringify(standing.office)} is not ` +
                 `an office ${resolved.address} names; it holds ${[...roster.keys()].join(", ")}`,

package/engine/stub-lint.mjs

@@ -12,14 +12,16 @@
  */
 
 /**
- * Every typed note needs a nonempty body.
+ * Every typed note needs content: an authored body or automatic lexical data.
  *
- * A missing or whitespace-only body is an error, whether or not the note has
+ * Without automatic lexical data, a missing or whitespace-only body is an error, whether or not the note has
  * a `draft` tag or a frontmatter description. Placeholder-only bodies remain
  * errors. A nonempty body below twenty-five words receives a warning when it
  * is not tagged `draft`; the author decides whether that short note is done.
  * A `folder` note is held only to the first rule: any nonempty body passes,
  * with or without `draft`.
+ * A language's nonempty `words`, or a culture's or affiliation's nonempty
+ * `glossary`, supplies an automatic section and needs no authored prose.
  *
  * Counts and the oldest drafts remain reports. Classification and indexing
  * still derive full, draft and stub states from the existing note records;
@@ -36,6 +38,7 @@ import { positionInFrontmatter, positionOfLiteral } from "./diagnostics.mjs";
 import { parseMarkdownFile } from "./helpers.mjs";
 import { bodyWordCount, placeholderBody } from "./note-state.mjs";
 import { isDraftNote } from "./note-vocabulary.mjs";
+import { hasLexicalEntries } from "./lexical-sections.mjs";
 
 /**
  * The word count below which an unmarked body is asked whether it is a draft.
@@ -62,6 +65,7 @@ function checkNote({ fm, body, file, raw }) {
     const at = (key, value) => positionInFrontmatter(raw, key, value, { topLevel: true });
 
     if (String(body ?? "").trim() === "") {
+        if (hasLexicalEntries(fm)) return findings;
         findings.push({
             file,
             ...at("type", fm.type),