@heroiclands/package-build 23.6.0 → 23.6.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @heroiclands/package-build
 
+## 23.6.1
+
+### Patch Changes
+
+**Dictionaries and glossaries**
+
+- A language's Suffixes and Fields tables can be set from its frontmatter, by querying `affixes` and `fields` in an `sql` fence.
+- An affix can state its own tone pattern in `tones`.
+- `key=false` leaves the key off a dictionary or glossary fence, so a page with one fence per heading states the key once.
+- A daughter language's words built from its parent's words and affixes no longer warn that a piece matches nothing, and their glosses print.
+- Dictionaries abbreviate particle as _ptcl._, since _part._ reads as participle.
+
+**Diagnostics**
+
+- File paths stay relative to the working directory when `PACKAGE_BUILD_CONFIG` names the configuration through a symlinked path, as macOS temporary directories are.
+
 ## 23.6.0
 
 ### Minor Changes

package/docs/authoring/links-and-markup.md

@@ -309,18 +309,20 @@ A column's heading is its SQL alias, so `AS "Name"` is what a reader sees. A cel
 
 ### What a query can read
 
-| Relation           | What it holds                                                                                                                                                                                        |
-| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `notes`            | Every note except a stub. This is the one to use unless a stub is wanted.                                                                                                                            |
-| `entries`          | Every note, stubs included.                                                                                                                                                                          |
-| `events`           | One row per event a `lore`, `place` or `affiliation` note writes in `data.events`, with `whenSort` to order them by date.                                                                            |
-| `words`            | One row per word a language note writes in `data.words`, with that note as its `language`, its `position` and what it is built from.                                                                 |
-| `glossary`         | One row per entry a culture or an affiliation writes in `data.glossary`, with the `note` it belongs to and the `language` it resolves to.                                                            |
-| `language_lineage` | One row per language note and each language it inherits words from through `data.family`, itself included at `depth` 0. Join it to `words` for a language's words with inherited ones.               |
-| `dictionary`       | One row per word per language it is listed under, inherited words included, with its `depth`. See [dictionaries and glossaries](#dictionaries-and-glossaries).                                       |
-| `terms`            | One row per glossary entry, rank or office per note that owns it, with the `cultures` it reaches. See [dictionaries and glossaries](#dictionaries-and-glossaries).                                   |
-| `market`           | The market scale as three columns — `value`, `name`, `trade` — so a table can print `village` beside the number a note wrote.                                                                        |
-| `<package>.notes`  | The same relations — `notes`, `entries`, `events`, `words`, `glossary`, `language_lineage`, `dictionary` and `terms` — for each package this one declares a dependency on, in a schema named for it. |
+| Relation           | What it holds                                                                                                                                                                                                             |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `notes`            | Every note except a stub. This is the one to use unless a stub is wanted.                                                                                                                                                 |
+| `entries`          | Every note, stubs included.                                                                                                                                                                                               |
+| `events`           | One row per event a `lore`, `place` or `affiliation` note writes in `data.events`, with `whenSort` to order them by date.                                                                                                 |
+| `words`            | One row per word a language note writes in `data.words`, with that note as its `language`, its `position` and what it is built from.                                                                                      |
+| `affixes`          | One row per affix a language note writes in `data.affixes`, with that note as its `language`, its `position`, and each key the affix states: `form`, `gloss`, `attaches`, `examples` and `tones`.                         |
+| `fields`           | One row per field a language note writes in `data.fields`, with that note as its `language`, its `position`, and the field's `name` and what it `holds`.                                                                  |
+| `glossary`         | One row per entry a culture or an affiliation writes in `data.glossary`, with the `note` it belongs to and the `language` it resolves to.                                                                                 |
+| `language_lineage` | One row per language note and each language it inherits words from through `data.family`, itself included at `depth` 0. Join it to `words` for a language's words with inherited ones.                                    |
+| `dictionary`       | One row per word per language it is listed under, inherited words included, with its `depth`. See [dictionaries and glossaries](#dictionaries-and-glossaries).                                                            |
+| `terms`            | One row per glossary entry, rank or office per note that owns it, with the `cultures` it reaches. See [dictionaries and glossaries](#dictionaries-and-glossaries).                                                        |
+| `market`           | The market scale as three columns — `value`, `name`, `trade` — so a table can print `village` beside the number a note wrote.                                                                                             |
+| `<package>.notes`  | The same relations — `notes`, `entries`, `events`, `words`, `affixes`, `fields`, `glossary`, `language_lineage`, `dictionary` and `terms` — for each package this one declares a dependency on, in a schema named for it. |
 
 Nested frontmatter is addressed exactly as a note writes it: `name.full`, `sohl.weight`, `data.born`. Every Address is a string — the full canonical Address, as in `list_contains(data.parents, 'thalorna-note-place-xerathia')` — whichever package published it. Every note carries a computed `state` column of `full`, `draft` or `stub`. Notes tagged `gm` are absent from the relations on public surfaces.
 
@@ -417,14 +419,35 @@ ORDER BY e.whenSort, e.address
 
 An event with no `where.locus` keeps its row with an empty **Where** cell.
 
+### A language's affixes and fields
+
+`affixes` and `fields` hold the entries of a language note's `data.affixes` and `data.fields`, so a page can set them as tables. A Suffixes table is a `layout=table` fence over `affixes`; the `tones` key is the tone pattern an affix carries:
+
+````markdown
+```sql
+SELECT form AS "Suffix", attaches AS "Stem", gloss AS "Makes", array_to_string(examples, ', ') AS "Example", tones AS "Tones"
+FROM affixes
+WHERE language = 'thalorna-note-skill-ekpelulng' AND form LIKE '-%'
+ORDER BY position
+```
+````
+
+| Suffix | Stem  | Makes                                        | Example | Tones |
+| ------ | ----- | -------------------------------------------- | ------- | ----- |
+| -ndo   | added | the keeper of it: one who tends and holds it | luwando | L     |
+| -ma    | added | the child of it: one who is fed by it        | yesoma  | H     |
+
+`ORDER BY position` keeps the order the note states them in. The same shape serves `fields`, with `name` and `holds`.
+
 ### Fence attributes
 
-A braced list may follow the language on the opening fence. Three attributes are accepted, and anything else is reported by name.
+A braced list may follow the language on the opening fence. Four attributes are accepted, and anything else is reported by name.
 
 | Attribute       | Value                               | Default | What it does                                                                                                                                                                            |
 | --------------- | ----------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `allow-empty`   | `true` or `false`                   | `false` | Whether a query selecting no rows is allowed. A zero-row result is a finding otherwise, because a table that silently prints nothing is the commonest way a query goes wrong unnoticed. |
 | `section-level` | an integer from 1 through 6         | `2`     | The heading level given to each group a `_section` column creates, and to each letter of a dictionary or a glossary.                                                                    |
+| `key`           | `true` or `false`                   | `true`  | Whether a dictionary or a glossary prints its key. `false` leaves it out, for a page that states the key once above several fences.                                                     |
 | `layout`        | `table`, `dictionary` or `glossary` | `table` | How the result is set: as a table, as a dictionary of words, or as a glossary of terms — see [dictionaries and glossaries](#dictionaries-and-glossaries).                               |
 
 ````markdown
@@ -488,9 +511,17 @@ SELECT * FROM terms WHERE list_contains(cultures, 'thalorna-note-lore-provenzian
 ```
 ````
 
+A page that sets several fences, one per heading, states its key once and sets `key=false` on each fence, so the abbreviations are not repeated under every heading:
+
+````markdown
+```sql {layout=dictionary key=false section-level=4}
+SELECT * FROM dictionary WHERE language = 'thalorna-note-skill-vylarilng' AND depth = 0
+```
+````
+
 Either layout prints, in order:
 
-- **a key**, once, listing only the abbreviations the result uses — a language's tag, and for words a class or a modifier — each with what it stands for, and the common mark where an entry carries it;
+- **a key**, once, unless the fence sets `key=false`, listing only the abbreviations the result uses — a language's tag, and for words a class or a modifier — each with what it stands for, and the common mark where an entry carries it;
 - **a heading per letter**, at `section-level`, accents taken off and apostrophes skipped, so `'ostal` files under O and `Écuyer` under E;
 - **one paragraph per entry**: `•` for a common entry, the headword in bold, its pronunciation between slashes, its language tag in italics, the senses, and after a dash the notes it is cited from, as links.
 

package/docs/content-format.md

@@ -143,6 +143,6 @@ Places, affiliations, lore and beings may name their culture in `data.culture`,
 
 An affiliation may name the trade, temple or order tongue it keeps in its own `data.language`. An affiliation that reaches no culture is a warning, in a tree holding a culture note. A language needs no culture and no affiliation. See [type: affiliation](reference/format-details.md#type-affiliation).
 
-A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss, with its source, the pieces it is built from and the notes it is attested in, beside `data.classModifiers`, `data.fields` and `data.affixes`. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary terms in `data.glossary`, and every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with the cultures it reaches; a fence sets them with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. See [a language's words](reference/format-details.md#a-languages-words), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
+A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss, with its source, the pieces it is built from and the notes it is attested in, beside `data.classModifiers`, `data.fields` and `data.affixes`. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary terms in `data.glossary`, and every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `affixes`, `fields`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with the cultures it reaches; a fence sets them with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. See [a language's words](reference/format-details.md#a-languages-words), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
 
 Blockquote alerts use `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, or `[!]`, with optional attributes after the marker. They replace the former info and warn div fences; secret blocks remain supported. See [alerts](authoring/links-and-markup.md#alerts).

package/docs/reference/format-details.md

@@ -2827,6 +2827,16 @@ language note tagged `gm` contributes no row on a public surface. A row holds
 the words its own note states, and nothing more: a daughter language's
 inherited words are read through `language_lineage`.
 
+**`affixes`** is one row per entry of `data.affixes` on every language note,
+and **`fields`** one per entry of `data.fields`, in the order the note states
+them. Each has `language` and `position` as `words` does, then every key of the
+entry as its own column: `form`, `gloss`, `attaches`, `examples` and `tones` for
+an affix, `name` and `holds` for a field. A key an entry does not state is
+`NULL`, `examples` is a list, and a language note tagged `gm` contributes no
+row on a public surface. An affix's `tones` is the tone pattern it carries,
+written as a word's `tones` is; it is a key of its own and is never read out of
+`attaches`.
+
 **`language_lineage`** is one row per language note and each language it
 inherits words from through [`data.family`](#a-languages-words): `language`,
 `ancestor` and `depth`, with the language itself at depth `0`, its parent at
@@ -3143,10 +3153,11 @@ value containing spaces with double quotes and escape an internal quote as
 `\"`. Boolean values are exactly `true` or `false`; other spellings are
 errors. Duplicate and unknown attributes are errors.
 
-| Attribute                                   | What it does                                        |
-| ------------------------------------------- | --------------------------------------------------- |
-| `allow-empty=true`                          | Permits a query selecting no rows. Default `false`. |
-| `section-level=1` through `section-level=6` | Sets the heading level for `_section`. Default `2`. |
+| Attribute                                   | What it does                                                      |
+| ------------------------------------------- | ----------------------------------------------------------------- |
+| `allow-empty=true`                          | Permits a query selecting no rows. Default `false`.               |
+| `section-level=1` through `section-level=6` | Sets the heading level for `_section`. Default `2`.               |
+| `key=false`                                 | Leaves the key out of a dictionary or a glossary. Default `true`. |
 
 ##### Page lists
 
@@ -5234,11 +5245,12 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `words[].tones`           | `string`                                                                             | A tone pattern, as `LHL`                                                                                                                                                             |
 | `words[].root`            | `string`                                                                             | A consonantal skeleton, as `d-l-k`                                                                                                                                                   |
 | `words[].frame`           | `string`                                                                             | The frame a root is set in                                                                                                                                                           |
-| `affixes`                 | `{ form, gloss, attaches?, examples? }[]`                                            | `language` only: the affixes a word's `built` pieces may name                                                                                                                        |
+| `affixes`                 | `{ form, gloss, attaches?, examples?, tones? }[]`                                    | `language` only: the affixes a word's `built` pieces may name                                                                                                                        |
 | `affixes[].form`          | `string`, required                                                                   | The affix as a `built` piece names it, as `-rith`                                                                                                                                    |
 | `affixes[].gloss`         | `string`, required                                                                   | What it means                                                                                                                                                                        |
 | `affixes[].attaches`      | `string`                                                                             | How it attaches, as `replaces a closing vowel`                                                                                                                                       |
 | `affixes[].examples`      | `string[]`                                                                           | The names it is read from                                                                                                                                                            |
+| `affixes[].tones`         | `string`                                                                             | The tone pattern it carries, as `L`                                                                                                                                                  |
 
 #### A language's words
 
@@ -6743,7 +6755,7 @@ A base is one of these. A base marked `no` never prints in the glossary.
 | `adv`  | adv.         | adverb          | yes             |
 | `pron` | pron.        | pronoun         | yes             |
 | `num`  | num.         | numeral         | yes             |
-| `part` | part.        | particle        | yes             |
+| `part` | ptcl.        | particle        | yes             |
 | `art`  | art.         | article         | yes             |
 | `conj` | conj.        | conjunction     | yes             |
 | `dem`  | dem.         | demonstrative   | yes             |

package/docs/reference/note-types.md

@@ -492,6 +492,7 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.affixes[].gloss`         | a string                                                                          | yes      | What the affix means.                                                                                                                                                                                                                                                                                                                    |
 | `data.affixes[].attaches`      | a string                                                                          | no       | How it attaches, such as `replaces a closing vowel`.                                                                                                                                                                                                                                                                                     |
 | `data.affixes[].examples`      | a list of strings                                                                 | no       | The names the affix is read from.                                                                                                                                                                                                                                                                                                        |
+| `data.affixes[].tones`         | a tone pattern, such as `L`                                                       | no       | The tone pattern the affix carries, written as a word's `tones` is.                                                                                                                                                                                                                                                                      |
 
 **System mappings**
 

package/engine/dictionary-layout.mjs

@@ -21,7 +21,7 @@
  * column is read where the query selects it. The output is Markdown, so every
  * surface sets it as it sets a note:
  *
- * - **the key**, once, at the head: the abbreviations this rendering uses,
+ * - **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;
  * - **a heading per letter**, from `letter`, at the fence's `section-level`;
  * - **one paragraph per entry**: the common mark, the bold headword, the
@@ -92,6 +92,7 @@ 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} [showKey=true] - Whether the key is printed.
  * @property {string} [pageLanguage] - The language of the page the fence is
  *   on, which no entry is tagged with.
  */
@@ -189,6 +190,7 @@ function render(
         sectionLevel = 2,
         addressContext,
         labelOf = () => undefined,
+        showKey = true,
         pageLanguage,
     },
     words,
@@ -284,7 +286,7 @@ function render(
         if (usedModifiers.has(modifier.token))
             key.push(`_${modifier.abbreviation}_ ${modifier.expansion}`);
     if (anyCommon) key.push(`${COMMON_MARK} ${COMMON_KEY}`);
-    if (key.length) paragraphs.unshift(`**Key:** ${key.join("; ")}.`);
+    if (showKey && key.length) paragraphs.unshift(`**Key:** ${key.join("; ")}.`);
     return paragraphs.join("\n\n");
 }
 

package/engine/dictionary-rows.mjs

@@ -53,7 +53,7 @@ import { parseAddress, renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 import { parseWordClass, WORD_CLASS_BASES } from "./word-classes.mjs";
-import { isLanguageRecord, pieceGlosses } from "./word-rows.mjs";
+import { isLanguageRecord, lineageChain, pieceGlosses } from "./word-rows.mjs";
 
 /** Every column of the `dictionary` relation, in order. */
 export const DICTIONARY_COLUMNS = Object.freeze([
@@ -224,17 +224,14 @@ export function dictionaryAndTermRows(records, all = records) {
         const full = record.name?.full;
         return typeof full === "string" && full ? full : null;
     };
-    const lineage = (language) => {
-        const chain = [];
-        const seen = new Set();
-        for (let current = language; current && languages.has(current) && !seen.has(current);) {
-            seen.add(current);
-            chain.push(current);
-            const family = languages.get(current).data?.family;
-            current = typeof family === "string" && family ? family : undefined;
-        }
-        return chain;
-    };
+    const lineage = (language) =>
+        lineageChain(language, {
+            has: (key) => languages.has(key),
+            parentOf: (key) => {
+                const family = languages.get(key).data?.family;
+                return typeof family === "string" && family ? family : undefined;
+            },
+        });
     const ownWords = new Map();
     for (const [key, record] of languages) {
         const list = [];
@@ -470,7 +467,7 @@ export function dictionaryAndTermRows(records, all = records) {
             };
         const source = isMap(word.source) ? word.source : {};
         const built = Array.isArray(word.built) ? word.built.map(String) : [];
-        const glossOf = pieceGlosses(languages.get(statedIn)?.data);
+        const glossOf = pieceGlosses(...lineage(statedIn).map((key) => languages.get(key).data));
         const out = {
             ...blank,
             kind: typeof source.kind === "string" ? source.kind : null,

package/engine/language-words.mjs

@@ -52,7 +52,7 @@ import {
     pronunciationProblem,
 } from "./word-terms.mjs";
 import { WORD_CLASS_MODIFIERS, parseWordClass } from "./word-classes.mjs";
-import { pieceGlosses } from "./word-rows.mjs";
+import { lineageChain, pieceGlosses } from "./word-rows.mjs";
 
 const MODIFIER_TOKENS = new Set(WORD_CLASS_MODIFIERS.map((item) => item.token));
 
@@ -159,7 +159,21 @@ export function checkLanguageWords(note, { index } = {}) {
         return out;
     }
 
-    const glossOf = pieceGlosses(data);
+    // The language's own entries, then each ancestor's through `data.family`.
+    const ownAddress = ownKey(note, index);
+    const dataAt = (key) => {
+        const hit = index?.addressHit?.(key);
+        const target = hit?.fm ?? hit;
+        return target?.subType === LANGUAGE_SUBTYPE && isMap(target.data) ? target.data : undefined;
+    };
+    const ancestors =
+        index?.addressHit && stated("family") ?
+            lineageChain(addressKeyOf(data.family, index, "skill"), {
+                has: (key) => key !== ownAddress && dataAt(key) !== undefined,
+                parentOf: (key) => addressKeyOf(dataAt(key).family, index, "skill"),
+            }).map((key) => dataAt(key))
+        :   [];
+    const glossOf = pieceGlosses(data, ...ancestors);
     const used = new Set();
     const forms = new Map();
     listOf(data.words).forEach((word, i) => {
@@ -246,7 +260,7 @@ export function checkLanguageWords(note, { index } = {}) {
                     [...at("built"), j],
                     "warning",
                     `the piece \`${piece}\` of \`${word.form}\` matches no word or affix of this ` +
-                        "language, so it prints with no gloss",
+                        "language or its ancestors, so it prints with no gloss",
                 ),
             );
         });

package/engine/pack-config.mjs

@@ -695,7 +695,7 @@ export function loadPackConfig() {
 
     const explicit = process.env.PACKAGE_BUILD_CONFIG;
     const found = explicit ? undefined : resolveConfigFile();
-    const configPath = explicit ? path.resolve(explicit) : found.path;
+    let configPath = explicit ? path.resolve(explicit) : found.path;
 
     if (!configPath || !fs.existsSync(configPath)) {
         throw new Error(
@@ -713,6 +713,11 @@ export function loadPackConfig() {
         );
     }
 
+    // An explicit name is followed through any symlink, so the configuration's
+    // root agrees with `process.cwd()`, which is always a real path, and
+    // diagnostic paths relative to one read relative to the other.
+    if (explicit) configPath = fs.realpathSync(configPath);
+
     // Two different files, one of which is about to be ignored. Said out loud
     // because the alternative is a build that reads the parent
     // checkout's configuration, compiles the parent's tree, and reports it only

package/engine/sql-tables.mjs

@@ -32,11 +32,15 @@ import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs
 import { EVENT_COLUMNS, EVENT_SORT_COLUMNS, eventRows } from "./event-rows.mjs";
 import {
     GLOSSARY_COLUMNS,
+    AFFIX_COLUMNS,
+    FIELD_COLUMNS,
     LINEAGE_COLUMNS,
     ROW_INTEGER_COLUMNS,
     WORD_COLUMNS,
     glossaryRows,
     lineageRows,
+    affixRows,
+    fieldRows,
     wordRows,
 } from "./word-rows.mjs";
 import { DICTIONARY_COLUMNS, TERM_COLUMNS, dictionaryAndTermRows } from "./dictionary-rows.mjs";
@@ -94,6 +98,14 @@ export const SQL_FENCE_ATTRIBUTES = Object.freeze({
             "The heading level given to each group a `_section` column creates, and to each " +
             "letter of a dictionary or a glossary.",
     }),
+    key: Object.freeze({
+        value: "`true` or `false`",
+        default: "`true`",
+        summary:
+            "Whether a dictionary or a glossary prints its key, the line of abbreviations it " +
+            "uses. `false` leaves the key out, for a page that states it once above several " +
+            "fences.",
+    }),
     layout: Object.freeze({
         value: "`table`, `dictionary` or `glossary`",
         default: "`table`",
@@ -123,7 +135,7 @@ const escapeCell = (text) =>
  *
  * @param {string} markdown - The note body, frontmatter already stripped.
  * @returns {Array<{line: number, close: number, indent: string, query: string,
- *   allowEmpty: boolean, sectionLevel: number, layout: string, block: string}>} One entry per
+ *   allowEmpty: boolean, sectionLevel: number, showKey: boolean, layout: string, block: string}>} One entry per
  *   fence, in document order.
  */
 export function findSqlBlocks(markdown) {
@@ -158,6 +170,14 @@ export function findSqlBlocks(markdown) {
                 errors.push(error.message);
             }
         }
+        let showKey = true;
+        if (Object.hasOwn(args, "key")) {
+            try {
+                showKey = booleanAttribute(args.key, "key");
+            } catch (error) {
+                errors.push(error.message);
+            }
+        }
         if (!Number.isInteger(level) || level < 1 || level > 6)
             errors.push("section-level needs an integer from 1 through 6");
         const layout = String(args.layout ?? "table");
@@ -170,6 +190,7 @@ export function findSqlBlocks(markdown) {
             query: lines.slice(i + 1, close).join("\n"),
             allowEmpty,
             sectionLevel: level,
+            showKey,
             layout,
             problems: errors,
             args,
@@ -310,6 +331,8 @@ export async function openNotesDatabase(
     for (const relation of [
         "events",
         "words",
+        "affixes",
+        "fields",
         "glossary",
         "language_lineage",
         "dictionary",
@@ -522,11 +545,14 @@ async function createTableFromFile(connection, name, select) {
 }
 
 /**
- * Create the `words`, `glossary`, `language_lineage`, `dictionary` and `terms`
- * relations: one row per language note's word, one per culture's or
+ * Create the `words`, `affixes`, `fields`, `glossary`, `language_lineage`,
+ * `dictionary` and `terms` relations: one row per language note's word, one per
+ * its affix, one per its field, one per culture's or
  * affiliation's glossary entry as authored, one per language and ancestor, one
  * per word per language it is listed under, and one per term per owning note,
  * with the columns {@link module:engine/word-rows.WORD_COLUMNS},
+ * {@link module:engine/word-rows.AFFIX_COLUMNS},
+ * {@link module:engine/word-rows.FIELD_COLUMNS},
  * {@link module:engine/word-rows.GLOSSARY_COLUMNS},
  * {@link module:engine/word-rows.LINEAGE_COLUMNS},
  * {@link module:engine/dictionary-rows.DICTIONARY_COLUMNS} and
@@ -550,10 +576,24 @@ async function createWordRelations(connection, stem, records, prefix, audience)
     await createRowRelation(
         connection,
         `${stem}-words.jsonl`,
-        wordRows(visible),
+        wordRows(visible, records),
         `${prefix}words`,
         WORD_COLUMNS,
     );
+    await createRowRelation(
+        connection,
+        `${stem}-affixes.jsonl`,
+        affixRows(visible),
+        `${prefix}affixes`,
+        AFFIX_COLUMNS,
+    );
+    await createRowRelation(
+        connection,
+        `${stem}-fields.jsonl`,
+        fieldRows(visible),
+        `${prefix}fields`,
+        FIELD_COLUMNS,
+    );
     await createRowRelation(
         connection,
         `${stem}-glossary.jsonl`,
@@ -870,6 +910,7 @@ export async function prepareSqlTables(db, sources, { linkable, records, pageLan
                             setAs(result, {
                                 ...options,
                                 labelOf,
+                                showKey: block.showKey,
                                 pageLanguage: languageOf(source, frontmatter),
                             })
                         :   renderSqlTable(result, options),

package/engine/word-classes.mjs

@@ -70,7 +70,7 @@ export const WORD_CLASS_BASES = Object.freeze([
     base("adv", "adv.", "adverb", true),
     base("pron", "pron.", "pronoun", true),
     base("num", "num.", "numeral", true),
-    base("part", "part.", "particle", true),
+    base("part", "ptcl.", "particle", true),
     base("art", "art.", "article", true),
     base("conj", "conj.", "conjunction", true),
     base("dem", "dem.", "demonstrative", true),

package/engine/word-rows.mjs

@@ -33,7 +33,13 @@
 
 import { renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
-import { GLOSSARY_ENTRY_KEYS, LANGUAGE_SUBTYPE, WORD_KEYS } from "./word-terms.mjs";
+import {
+    AFFIX_KEYS,
+    FIELD_KEYS,
+    GLOSSARY_ENTRY_KEYS,
+    LANGUAGE_SUBTYPE,
+    WORD_KEYS,
+} from "./word-terms.mjs";
 
 /** The columns a word row carries before the word's own keys. */
 const WORD_IDENTITY_COLUMNS = Object.freeze(["language", "position"]);
@@ -51,6 +57,12 @@ export const WORD_COLUMNS = Object.freeze([
 /** Every column of the `glossary` relation, in order. */
 export const GLOSSARY_COLUMNS = Object.freeze(["note", "position", ...GLOSSARY_ENTRY_KEYS]);
 
+/** Every column of the `affixes` relation, in order. */
+export const AFFIX_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...AFFIX_KEYS]);
+
+/** Every column of the `fields` relation, in order. */
+export const FIELD_COLUMNS = Object.freeze([...WORD_IDENTITY_COLUMNS, ...FIELD_KEYS]);
+
 /** Every column of the `language_lineage` relation, in order. */
 export const LINEAGE_COLUMNS = Object.freeze(["language", "ancestor", "depth"]);
 
@@ -64,17 +76,20 @@ const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.i
 const bare = (form) => String(form).replace(/^-+|-+$/g, "");
 
 /**
- * A lookup from a built piece to its gloss, over one language's words (stems
- * included) and affixes.
+ * A lookup from a built piece to its gloss, over the words (stems included)
+ * and affixes of one or more languages.
  *
- * A piece matches a word or an affix written exactly as it is, and failing
+ * Languages are given nearest first: a language's own words, then its own
+ * affixes, then the next language's, so a daughter's entry wins over its
+ * parent's. A piece matches an entry written exactly as it is, and failing
  * that one written with the same letters and different joining hyphens, so
- * `wulf-` finds the word `wulf`. A word's own gloss wins over an affix's.
+ * `wulf-` finds the word `wulf`. Within a language a word's own gloss wins over
+ * an affix's.
  *
- * @param {object} data - The language note's `data`.
+ * @param {...object} datas - Each language note's `data`, nearest first.
  * @returns {(piece: string) => string|null} The gloss, or `null` where none resolves.
  */
-export function pieceGlosses(data) {
+export function pieceGlosses(...datas) {
     const exact = new Map();
     const loose = new Map();
     const take = (entries) => {
@@ -85,11 +100,64 @@ export function pieceGlosses(data) {
             if (!loose.has(bare(entry.form))) loose.set(bare(entry.form), entry.gloss);
         }
     };
-    take(data?.words);
-    take(data?.affixes);
+    for (const data of datas) {
+        take(data?.words);
+        take(data?.affixes);
+    }
     return (piece) => exact.get(piece) ?? loose.get(bare(piece)) ?? null;
 }
 
+/**
+ * The chain of languages from one up through `data.family`: the language
+ * itself, then its parent, and so on. The chain stops at a parent that is no
+ * language, and before a language it has already reached, so a cycle the lint
+ * refuses still yields a finite chain. `language_lineage`, the dictionary and
+ * the resolution of built pieces all walk it.
+ *
+ * @param {string|undefined} start - The language's key.
+ * @param {object} reader
+ * @param {(key: string) => boolean} reader.has - Whether a key is a language.
+ * @param {(key: string) => string|undefined} reader.parentOf - A language's
+ *   parent key, where it states one.
+ * @returns {string[]} The keys, nearest first.
+ */
+export function lineageChain(start, { has, parentOf }) {
+    const chain = [];
+    const seen = new Set();
+    for (let current = start; current && has(current) && !seen.has(current);) {
+        seen.add(current);
+        chain.push(current);
+        current = parentOf(current) || undefined;
+    }
+    return chain;
+}
+
+/** A language record's `data.family` where it is a plain Address string. */
+const familyKey = (record) => {
+    const family = record?.data?.family;
+    return typeof family === "string" && family ? family : undefined;
+};
+
+/**
+ * A lookup of language records by Address, and the chain walk over them.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {{languages: Map<string, object>, chain: (key: string) => string[]}}
+ */
+export function languageLineages(records) {
+    const languages = new Map();
+    for (const record of records)
+        if (isLanguageRecord(record)) {
+            const key = noteAddressOf(record);
+            if (key && !languages.has(key)) languages.set(key, record);
+        }
+    const reader = {
+        has: (key) => languages.has(key),
+        parentOf: (key) => familyKey(languages.get(key)),
+    };
+    return { languages, chain: (key) => lineageChain(key, reader) };
+}
+
 /**
  * Whether a record is a language note's.
  *
@@ -124,9 +192,12 @@ function noteAddressOf(record) {
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.
+ * @param {Iterable<Record<string, any>>} [all] - Every record of the package,
+ *   for resolving a built piece through an ancestor the audience does not see.
  * @returns {object[]} One row per word, in record then entry order.
  */
-export function wordRows(records) {
+export function wordRows(records, all = records) {
+    const { languages, chain } = languageLineages(all);
     const rows = [];
     for (const record of records) {
         if (!isLanguageRecord(record)) continue;
@@ -134,7 +205,7 @@ export function wordRows(records) {
         if (!Array.isArray(words) || !words.length) continue;
         const language = noteAddressOf(record);
         if (!language) continue;
-        const glossOf = pieceGlosses(record.data);
+        const glossOf = pieceGlosses(...chain(language).map((key) => languages.get(key).data));
         words.forEach((entry, position) => {
             if (!isMap(entry)) return;
             const row = { language, position };
@@ -150,6 +221,57 @@ export function wordRows(records) {
     return rows;
 }
 
+/**
+ * The rows of one list a language note states beside its words: one per entry,
+ * keyed by the note, with every key of the entry a column.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @param {string} list - The `data` key holding the entries.
+ * @param {readonly string[]} keys - The keys an entry carries.
+ * @returns {object[]} One row per entry, in record then entry order.
+ */
+function languageListRows(records, list, keys) {
+    const rows = [];
+    for (const record of records) {
+        if (!isLanguageRecord(record)) continue;
+        const entries = record.data?.[list];
+        if (!Array.isArray(entries) || !entries.length) continue;
+        const language = noteAddressOf(record);
+        if (!language) continue;
+        entries.forEach((entry, position) => {
+            if (!isMap(entry)) return;
+            const row = { language, position };
+            for (const key of keys) row[key] = entry[key] ?? null;
+            rows.push(row);
+        });
+    }
+    return rows;
+}
+
+/**
+ * The `affixes` rows of a set of index records: one per `data.affixes` entry
+ * of a language note, which is the row's `language`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @returns {object[]} One row per affix, in record then entry order.
+ */
+export function affixRows(records) {
+    return languageListRows(records, "affixes", AFFIX_KEYS);
+}
+
+/**
+ * The `fields` rows of a set of index records: one per `data.fields` entry of
+ * a language note, which is the row's `language`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @returns {object[]} One row per field, in record then entry order.
+ */
+export function fieldRows(records) {
+    return languageListRows(records, "fields", FIELD_KEYS);
+}
+
 /**
  * The `glossary` rows of a set of index records: one per entry of a culture's
  * or an affiliation's `data.glossary`, with `name_sort` the name and `common`
@@ -209,25 +331,13 @@ export function glossaryRows(records, all = records) {
  * @returns {object[]} One row per language and ancestor, in record then depth order.
  */
 export function lineageRows(records, all = records) {
-    const languages = new Map();
-    for (const record of all)
-        if (isLanguageRecord(record)) {
-            const key = noteAddressOf(record);
-            if (key && !languages.has(key)) languages.set(key, record);
-        }
+    const { chain } = languageLineages(all);
     const rows = [];
     for (const record of records) {
         if (!isLanguageRecord(record)) continue;
         const language = noteAddressOf(record);
         if (!language) continue;
-        const seen = new Set();
-        let current = language;
-        for (let depth = 0; current && languages.has(current) && !seen.has(current); depth++) {
-            seen.add(current);
-            rows.push({ language, ancestor: current, depth });
-            const family = languages.get(current).data?.family;
-            current = typeof family === "string" && family ? family : undefined;
-        }
+        chain(language).forEach((ancestor, depth) => rows.push({ language, ancestor, depth }));
     }
     return rows;
 }

package/engine/word-terms.mjs

@@ -226,8 +226,20 @@ export const AFFIX_FIELDS = Object.freeze([
         entries: Object.freeze({ kind: "string", shape: "a string" }),
         describe: "The names the affix is read from.",
     }),
+    Object.freeze({
+        name: "tones",
+        kind: "string",
+        shape: "a tone pattern, such as `L`",
+        describe: "The tone pattern the affix carries, written as a word's `tones` is.",
+    }),
 ]);
 
+/** The keys of {@link WORD_FIELD_FIELDS}, in declared order. */
+export const FIELD_KEYS = Object.freeze(WORD_FIELD_FIELDS.map((field) => field.name));
+
+/** The keys of {@link AFFIX_FIELDS}, in declared order. */
+export const AFFIX_KEYS = Object.freeze(AFFIX_FIELDS.map((field) => field.name));
+
 /**
  * The keys one entry of a culture's or an affiliation's `data.glossary`
  * carries.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.6.0",
+    "version": "23.6.1",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/types/engine/dictionary-layout.d.mts

@@ -6,6 +6,7 @@
  * @property {object} [addressContext] - Address resolution context.
  * @property {(address: string) => string|undefined} [labelOf] - A note's
  *   `name.full`, by its Address.
+ * @property {boolean} [showKey=true] - Whether the key is printed.
  * @property {string} [pageLanguage] - The language of the page the fence is
  *   on, which no entry is tagged with.
  */
@@ -61,6 +62,10 @@ export type LayoutOptions = {
      * `name.full`, by its Address.
      */
     labelOf?: ((address: string) => string | undefined) | undefined;
+    /**
+     * - Whether the key is printed.
+     */
+    showKey?: boolean | undefined;
     /**
      * - The language of the page the fence is
      * on, which no entry is tagged with.

package/types/engine/sql-tables.d.mts

@@ -7,7 +7,7 @@
  *
  * @param {string} markdown - The note body, frontmatter already stripped.
  * @returns {Array<{line: number, close: number, indent: string, query: string,
- *   allowEmpty: boolean, sectionLevel: number, layout: string, block: string}>} One entry per
+ *   allowEmpty: boolean, sectionLevel: number, showKey: boolean, layout: string, block: string}>} One entry per
  *   fence, in document order.
  */
 export function findSqlBlocks(markdown: string): Array<{
@@ -17,6 +17,7 @@ export function findSqlBlocks(markdown: string): Array<{
     query: string;
     allowEmpty: boolean;
     sectionLevel: number;
+    showKey: boolean;
     layout: string;
     block: string;
 }>;

package/types/engine/word-rows.d.mts

@@ -1,15 +1,46 @@
 /**
- * A lookup from a built piece to its gloss, over one language's words (stems
- * included) and affixes.
+ * A lookup from a built piece to its gloss, over the words (stems included)
+ * and affixes of one or more languages.
  *
- * A piece matches a word or an affix written exactly as it is, and failing
+ * Languages are given nearest first: a language's own words, then its own
+ * affixes, then the next language's, so a daughter's entry wins over its
+ * parent's. A piece matches an entry written exactly as it is, and failing
  * that one written with the same letters and different joining hyphens, so
- * `wulf-` finds the word `wulf`. A word's own gloss wins over an affix's.
+ * `wulf-` finds the word `wulf`. Within a language a word's own gloss wins over
+ * an affix's.
  *
- * @param {object} data - The language note's `data`.
+ * @param {...object} datas - Each language note's `data`, nearest first.
  * @returns {(piece: string) => string|null} The gloss, or `null` where none resolves.
  */
-export function pieceGlosses(data: object): (piece: string) => string | null;
+export function pieceGlosses(...datas: object[]): (piece: string) => string | null;
+/**
+ * The chain of languages from one up through `data.family`: the language
+ * itself, then its parent, and so on. The chain stops at a parent that is no
+ * language, and before a language it has already reached, so a cycle the lint
+ * refuses still yields a finite chain. `language_lineage`, the dictionary and
+ * the resolution of built pieces all walk it.
+ *
+ * @param {string|undefined} start - The language's key.
+ * @param {object} reader
+ * @param {(key: string) => boolean} reader.has - Whether a key is a language.
+ * @param {(key: string) => string|undefined} reader.parentOf - A language's
+ *   parent key, where it states one.
+ * @returns {string[]} The keys, nearest first.
+ */
+export function lineageChain(start: string | undefined, { has, parentOf }: {
+    has: (key: string) => boolean;
+    parentOf: (key: string) => string | undefined;
+}): string[];
+/**
+ * A lookup of language records by Address, and the chain walk over them.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {{languages: Map<string, object>, chain: (key: string) => string[]}}
+ */
+export function languageLineages(records: Iterable<Record<string, any>>): {
+    languages: Map<string, object>;
+    chain: (key: string) => string[];
+};
 /**
  * Whether a record is a language note's.
  *
@@ -24,9 +55,29 @@ export function isLanguageRecord(record: Record<string, any>): boolean;
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.
+ * @param {Iterable<Record<string, any>>} [all] - Every record of the package,
+ *   for resolving a built piece through an ancestor the audience does not see.
  * @returns {object[]} One row per word, in record then entry order.
  */
-export function wordRows(records: Iterable<Record<string, any>>): object[];
+export function wordRows(records: Iterable<Record<string, any>>, all?: Iterable<Record<string, any>>): object[];
+/**
+ * The `affixes` rows of a set of index records: one per `data.affixes` entry
+ * of a language note, which is the row's `language`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @returns {object[]} One row per affix, in record then entry order.
+ */
+export function affixRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `fields` rows of a set of index records: one per `data.fields` entry of
+ * a language note, which is the row's `language`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @returns {object[]} One row per field, in record then entry order.
+ */
+export function fieldRows(records: Iterable<Record<string, any>>): object[];
 /**
  * The `glossary` rows of a set of index records: one per entry of a culture's
  * or an affiliation's `data.glossary`, with `name_sort` the name and `common`
@@ -58,6 +109,10 @@ export function lineageRows(records: Iterable<Record<string, any>>, all?: Iterab
 export const WORD_COLUMNS: readonly string[];
 /** Every column of the `glossary` relation, in order. */
 export const GLOSSARY_COLUMNS: readonly string[];
+/** Every column of the `affixes` relation, in order. */
+export const AFFIX_COLUMNS: readonly string[];
+/** Every column of the `fields` relation, in order. */
+export const FIELD_COLUMNS: readonly string[];
 /** Every column of the `language_lineage` relation, in order. */
 export const LINEAGE_COLUMNS: readonly string[];
 /** The columns of any of these relations that hold a whole number. */

package/types/engine/word-terms.d.mts

@@ -57,6 +57,10 @@ export const WORD_FIELD_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const AFFIX_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/** The keys of {@link WORD_FIELD_FIELDS}, in declared order. */
+export const FIELD_KEYS: readonly string[];
+/** The keys of {@link AFFIX_FIELDS}, in declared order. */
+export const AFFIX_KEYS: readonly string[];
 /**
  * The keys one entry of a culture's or an affiliation's `data.glossary`
  * carries.