@heroiclands/package-build 23.8.0 → 23.10.0

package/engine/dictionary-layout.mjs

@@ -22,18 +22,21 @@
  * surface sets it as it sets a note:
  *
  * - **the key**, once, at the head unless the fence sets `key=false`: the abbreviations this rendering uses,
- *   each with its expansion, then the common mark where an entry carries it.
+ *   each with its expansion, then a glossary's common mark where an entry carries it.
  *   A fence setting `key=only` prints the key alone;
  * - **a heading per letter**, from `letter`, at the fence's `section-level`;
  * - **one paragraph per entry**: the common mark, the bold headword, the
- *   pronunciation between slashes, the language tag (and for a word its
- *   class) in italics, a word's etymology in brackets, the senses, and the
+ *   pronunciation between slashes, the language tag and word class in
+ *   italics, a dictionary word's field tag and etymology in brackets, the senses, and the
  *   citations as links.
  *
  * A glossary sets the rows that share a headword and a language as one entry:
  * their senses numbered in the order the rows arrive, each tagged with the
- * bodies it comes from, a sense several rows give printed once with all of
- * them. A word's senses carry no bodies, and a glossary's always do.
+ * bodies it comes from, except a sole owner's label on its own page. A sense
+ * several rows give is printed once with all its bodies. A dictionary word's
+ * senses carry no bodies; a glossary's contextual
+ * and governance senses name their owners. A glossary headword naming a
+ * dictionary word links to that word's anchored entry on its language page.
  *
  * The entries are ordered here rather than by the query: by letter, then by
  * `name_sort` with its accents taken off and its case folded, then as written.
@@ -43,8 +46,9 @@
  * @module
  */
 
-import { parseAddress, renderAddress } from "./address.mjs";
-import { dictionaryLetter } from "./dictionary-rows.mjs";
+import { parseAddress, readCanonicalKey, renderAddress, splitAnchor } from "./address.mjs";
+import { dictionaryEntryAnchor, dictionaryLetter } from "./dictionary-rows.mjs";
+import { VERB_PERSON_FIELDS } from "./language-terms.mjs";
 import {
     WORD_CLASS_BASES,
     WORD_CLASS_MODIFIERS,
@@ -61,6 +65,50 @@ export const LAYOUT_REQUIRED_COLUMNS = Object.freeze({
 /** The mark a common entry opens with. */
 export const COMMON_MARK = "•";
 
+/** The word-entry span class whose Foundry rendering is a native TOC heading. */
+export const DICTIONARY_ENTRY_CLASS = "dictionary-entry";
+
+/**
+ * Render a dictionary entry's marked headword as an inline native heading in
+ * Foundry. Its paragraph becomes a div, so the heading has a valid container.
+ * The shared Markdown keeps its span and its containing journal page.
+ *
+ * @param {import("markdown-it")} md - The Foundry Markdown parser.
+ */
+export function dictionaryEntryPlugin(md) {
+    md.core.ruler.after("inline", "dictionary_entry_headings", (state) => {
+        for (let i = 1; i < state.tokens.length - 1; i++) {
+            const inline = state.tokens[i];
+            const opening = inline.children?.[0];
+            if (
+                inline.type !== "inline" ||
+                state.tokens[i - 1].type !== "paragraph_open" ||
+                state.tokens[i + 1].type !== "paragraph_close" ||
+                opening?.type !== "span_open" ||
+                !opening.attrGet("id") ||
+                !String(opening.attrGet("class") ?? "")
+                    .split(/\s+/)
+                    .includes(DICTIONARY_ENTRY_CLASS)
+            )
+                continue;
+            let depth = 0;
+            const closing = inline.children.find((token) => {
+                if (token.type === "span_open") depth++;
+                if (token.type === "span_close") return --depth === 0;
+                return false;
+            });
+            if (!closing) continue;
+            opening.tag = closing.tag = "h6";
+            opening.attrSet(
+                "style",
+                "display: inline; margin: 0; padding: 0; border: 0; font: inherit; text-transform: none",
+            );
+            state.tokens[i - 1].tag = state.tokens[i + 1].tag = "div";
+            state.tokens[i - 1].attrSet("style", "margin: 0 0 0.5em");
+        }
+    });
+}
+
 /** What the key says of the common mark. */
 const COMMON_KEY = "a common word, which a player is expected to know by heart";
 
@@ -93,10 +141,16 @@ function sentence(text) {
  * @property {object} [addressContext] - Address resolution context.
  * @property {(address: string) => string|undefined} [labelOf] - A note's
  *   `name.full`, by its Address.
- * @property {boolean|"only"} [showKey=true] - Whether the key is printed;
- *   `"only"` prints the key and nothing else.
+ * @property {boolean|"only"} [showKey=true] - Whether the key and dictionary
+ *   head tables are printed; `"only"` prints the key and nothing else.
  * @property {string} [pageLanguage] - The language of the page the fence is
  *   on, which no entry is tagged with.
+ * @property {string} [pageOwner] - The containing page's canonical note Address;
+ *   a sense attributed only to its own row's owner omits that label on this page.
+ * @property {boolean} [entryAnchors=true] - Whether dictionary headwords carry
+ *   their canonical targets; custom SQL views leave those to the automatic list.
+ * @property {object} [verbs] - The owning language's stated pattern, including
+ *   when its automatic dictionary has no eligible word entries.
  */
 
 /**
@@ -114,9 +168,56 @@ export function renderDictionary(result, opts = {}) {
         result.rows.map((row) => ({ ...row, rows: [row] })),
         opts,
         true,
+        verbTables(result.rows, opts),
     );
 }
 
+/** A table cell cannot carry a literal pipe or a line break. */
+const verbCell = (text) =>
+    String(text)
+        .replace(/\|/g, "\\|")
+        .replace(/[\r\n]+/g, " ");
+
+/** One head table per represented language, with no forms invented for a word. */
+function verbTables(rows, opts) {
+    const patterns = new Map();
+    for (const row of rows)
+        if (row.verbs && typeof row.verbs === "object")
+            patterns.set(row.language ?? opts.pageLanguage ?? "", {
+                verbs: row.verbs,
+                label: row.language_tag,
+            });
+    if (opts.verbs && !patterns.has(opts.pageLanguage ?? ""))
+        patterns.set(opts.pageLanguage ?? "", { verbs: opts.verbs });
+    const tables = [];
+    for (const [language, { verbs, label }] of [...patterns].sort(([a], [b]) => compare(a, b))) {
+        let endings;
+        if (verbs.invariant === true) endings = [["All persons", "unchanged"]];
+        else if (
+            VERB_PERSON_FIELDS.every((person) => typeof verbs.persons?.[person.name] === "string")
+        )
+            endings = VERB_PERSON_FIELDS.map((person) => [
+                person.label,
+                verbs.persons[person.name] ? `-${verbs.persons[person.name]}` : "unchanged",
+            ]);
+        else continue;
+        const title =
+            patterns.size > 1 ?
+                `**Verbs (${String(opts.labelOf?.(language) ?? label ?? language).replace(/[\r\n]+/g, " ")})**`
+            :   "**Verbs**";
+        tables.push(
+            [
+                title,
+                "",
+                "| Person | Ending added to citation form |",
+                "| --- | --- |",
+                ...endings.map((ending) => `| ${ending.map(verbCell).join(" | ")} |`),
+            ].join("\n"),
+        );
+    }
+    return tables.join("\n\n");
+}
+
 /**
  * Render a result of terms as a glossary.
  *
@@ -141,10 +242,18 @@ export function renderGlossary(result, opts = {}) {
                 for (const sense of Array.isArray(row.senses) ? row.senses : []) {
                     const same = senses.find((one) => one.text === sense?.text);
                     const bodies = Array.isArray(sense?.bodies) ? sense.bodies : [];
-                    if (!same) senses.push({ text: sense?.text, bodies: [...bodies] });
-                    else
+                    const omitBody = Boolean(
+                        opts.pageOwner &&
+                        row.owner === opts.pageOwner &&
+                        bodies.length === 1 &&
+                        bodies[0] === row.owner,
+                    );
+                    if (!same) senses.push({ text: sense?.text, bodies: [...bodies], omitBody });
+                    else {
+                        same.omitBody &&= omitBody;
                         for (const body of bodies)
                             if (!same.bodies.includes(body)) same.bodies.push(body);
+                    }
                 }
             for (const sense of senses) sense.bodies.sort(compare);
             const first = (column) =>
@@ -157,7 +266,8 @@ export function renderGlossary(result, opts = {}) {
                 pronunciation: first("pronunciation"),
                 name_sort: first("name_sort"),
                 letter: first("letter"),
-                class: undefined,
+                class: first("class"),
+                word: first("word"),
                 etymology: undefined,
             };
         }),
@@ -181,8 +291,9 @@ function requireColumns(result, layout) {
  *
  * @param {object[]} entries - One per entry, with the row columns.
  * @param {LayoutOptions} opts
- * @param {boolean} words - Whether the entries are words, with a class and an
- *   etymology.
+ * @param {boolean} words - Whether the entries are dictionary words, with
+ *   their own anchors and etymology.
+ * @param {string} [head] - Optional dictionary head tables.
  * @returns {string}
  */
 function render(
@@ -194,14 +305,17 @@ function render(
         labelOf = () => undefined,
         showKey = true,
         pageLanguage,
+        entryAnchors = true,
     },
     words,
+    head = "",
 ) {
     const label = (address) => labelOf(address) ?? address;
     const usedTags = new Map();
     const usedBases = new Set();
     const usedModifiers = new Set();
     let anyCommon = false;
+    let anyPlural = false;
 
     const cite = (address) => {
         const text = label(address);
@@ -236,25 +350,40 @@ function render(
             paragraphs.push(`${"#".repeat(sectionLevel)} ${letter}`);
         }
         const parts = [];
-        if (row.common === true) {
+        if (!words && row.common === true) {
             anyCommon = true;
             parts.push(COMMON_MARK);
         }
-        parts.push(`**${row.name}**`);
+        let headword = `**${row.name}**`;
+        if (words && entryAnchors && typeof row.language === "string")
+            headword = `[${headword}]{#${dictionaryEntryAnchor(row.language, row.name)} .${DICTIONARY_ENTRY_CLASS}}`;
+        else if (!words && typeof row.word === "string") {
+            const { address, anchor } = splitAnchor(row.word);
+            const ref = readCanonicalKey(address);
+            if (ref && anchor && linkable(ref))
+                headword = `**[[${renderAddress(ref)}#${anchor}|${String(row.name).replace(/\|/g, "/")}]]**`;
+        }
+        parts.push(headword);
         if (row.pronunciation) parts.push(`/${row.pronunciation}/`);
 
         const italic = [];
         if (row.language_tag && row.language !== pageLanguage)
             italic.push(tag(row.language, row.language_tag));
-        if (words && row.class) {
+        if (row.class) {
             const parsed = parseWordClass(row.class);
             if (!parsed.reason) {
                 usedBases.add(parsed.base);
                 for (const token of parsed.modifiers) usedModifiers.add(token);
-                italic.push(abbreviateWordClass(parsed));
+                let classification = abbreviateWordClass(parsed);
+                if (words && parsed.base === "n" && typeof row.plural === "string" && row.plural) {
+                    classification += `, pl. ${row.plural}`;
+                    anyPlural = true;
+                }
+                italic.push(classification);
             } else italic.push(String(row.class));
         }
         if (italic.length) parts.push(`_${italic.join(" ")}_`);
+        if (words && row.field) parts.push(`(_${row.field}_)`);
 
         if (words) {
             const bracket = etymologyText(row.etymology, row.language, tag);
@@ -264,7 +393,8 @@ function render(
         const senses = Array.isArray(row.senses) ? row.senses : [];
         const senseText = (sense) => {
             const bodies = Array.isArray(sense?.bodies) ? sense.bodies : [];
-            const by = bodies.length ? `(_${bodies.map(label).join(", ")}_) ` : "";
+            const by =
+                bodies.length && !sense.omitBody ? `(_${bodies.map(label).join(", ")}_) ` : "";
             return `${by}${sentence(sense?.text)}`;
         };
         if (senses.length === 1) parts.push(senseText(senses[0]));
@@ -287,9 +417,11 @@ function render(
     for (const modifier of WORD_CLASS_MODIFIERS)
         if (usedModifiers.has(modifier.token))
             key.push(`_${modifier.abbreviation}_ ${modifier.expansion}`);
+    if (anyPlural) key.push("_pl._ plural");
     if (anyCommon) key.push(`${COMMON_MARK} ${COMMON_KEY}`);
     const line = key.length ? `**Key:** ${key.join("; ")}.` : "";
     if (showKey === "only") return line;
+    if (showKey && head) paragraphs.unshift(head);
     if (showKey && line) paragraphs.unshift(line);
     return paragraphs.join("\n\n");
 }

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) =>