@heroiclands/package-build 23.8.0 → 23.10.0

package/docs/authoring/first-note.md

@@ -45,4 +45,4 @@ The full Address is `<package>-note-lore-harbor`; `<package>` comes from `conten
 
 Add `description` for a short page summary, `tags: [draft]` to mark unfinished prose, or `data` for fields the note's type permits. A system block such as `sohl:` or `hm3:` adds mechanics and can produce a Foundry Actor or Item. It does not replace the shared prose or make another JournalEntry. [Frontmatter](frontmatter.md) explains the allowed keys, and the [note-type reference](../reference/note-types.md) lists every type-specific field.
 
-Every typed note must have a nonempty body after its frontmatter. An empty or whitespace-only body is an error, even with `tags: [draft]` or a description. This includes folder and homepage notes. A nonempty body with fewer than 25 prose words produces a warning unless the note has a `draft` tag. A folder note needs only a nonempty body: any content passes, with or without the tag. See [note states](../reference/format-details.md#three-states-of-a-note).
+Nonempty `data.words` on a language note, or `data.glossary` on a culture or affiliation, supplies content without an authored body. Every other typed note must have a nonempty body after its frontmatter, including folder and homepage notes. An empty or whitespace-only body is otherwise an error, even with `tags: [draft]` or a description. A nonempty body with fewer than 25 prose words produces a warning unless the note has a `draft` tag. A folder note needs only a nonempty body: any content passes, with or without the tag. See [note states](../reference/format-details.md#three-states-of-a-note).

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

@@ -23,6 +23,69 @@ A link to a note tagged `draft` retains its target and carries a visible draft c
 
 An HTML comment is an aside to whoever reads the note next, and no surface shows one — the packs and the website emit it into the HTML, where it stays a comment, and a book leaves it out. Write a `markdownlint` pragma or a note about a quoted passage freely. A comment inside a fence or a code span is an example and is printed as written, and a comment that is never closed is an error.
 
+## Marking names in prose
+
+Use `[Name]{.name}` for a name that has no indexed note. Link a name that has
+one; an empty link label uses the indexed full name. Bold is emphasis.
+Plain text, including capitalized words, is not searched for names.
+
+```markdown
+[[place-arden|Arden Vale]] stands beside the river. Arden Vale has two gates.
+[Hidden Hand]{.name} keeps watch over the crossing.
+```
+
+To name something that has no note yet, mark it with its type instead of
+creating a placeholder note:
+
+```markdown
+[Ravenmoor]{.name data-type="place/settlement"}
+[Aldric Venn]{.name data-type="being"}
+```
+
+`data-type` is optional. It names a declared [note type and
+subtype](../reference/note-types.md), written as `type` or `type/subType`.
+Enumerated subtypes must belong to that type's list; an open declaration
+accepts a well-formed note subtype, and a type without a subtype declaration
+takes only the bare type. An invalid supplied value is an error at the
+attribute. Site and Foundry spans retain the classes and attribute values;
+the attribute adds no book presentation.
+
+`package-build lint` warns when an indexed name or alias uses `.name`
+instead of a link, when the same name is marked or linked again, or when a
+short form appears before its full name. Only marked names and authored link
+labels count toward these rules. Introduce the full name before an alias such
+as `Arden`, then use plain text for later mentions. Full names and their
+declared aliases count as the same name, including in links to different
+headings. Different labels do not become the same name just because they link
+to the same page.
+
+A name span can sit inside emphasis:
+
+```markdown
+**This is a phrase with [Joe Blow]{.name} in it**
+```
+
+The marked name is `Joe Blow`. Sites and books display `.name` text in bold, including
+inside an emphasized phrase. A whole bold span matching an indexed name or
+alias receives an advisory to mark or link that name; bold containing an
+explicit name span or link needs no such advisory.
+
+These are warnings at each occurrence's `file:line:column`; they do not make
+a valid package fail. The check reads authored prose outside headings,
+tables, infoboxes, code, frontmatter, comments and embeds. See the
+[complete name-marking rules](../reference/format-details.md#marking-names-in-prose).
+
+The index records every actual `.name` span in the authored body, including
+headings, tables, verse and spans inside links. The `names` SQL relation holds
+its visible text, optional type/subtype and source location. Plain prose, bold,
+unmarked link labels and generated content add no rows.
+
+Lint also gives one grouped package advisory for names without a matching
+indexed full name or alias, and for conflicting supplied classifications. It
+lists every use and starts at the earliest reported span. Untyped uses do not
+conflict, and `place` agrees with `place/settlement`; different supplied types
+or different supplied subtypes conflict. These advisories do not fail lint.
+
 ## Journal pages and anchors
 
 Every H1 starts a JournalEntryPage. A lower-level heading with an explicit anchor starts a page too. Use `{#slug}` to make a stable target:
@@ -128,6 +191,9 @@ An attribute-bearing opener allows a nested div to be distinguished from the bar
 The watch wears [a _blue_ sash]{#watch-sash .uniform lang=en}.
 ```
 
+Use `[Ravenmoor]{.name data-type="place/settlement"}` to mark a name with its
+optional declared type; see [marking names](#marking-names-in-prose).
+
 Inline Markdown remains active inside the span. Bracket spans have lower priority than URL links, image links, reference links, footnotes and wikilinks. A bracketed form immediately preceded by `!`, followed by `(` or another `[`, or beginning with `[[` is not a span, even when the link is unresolved. Ordinary links retain their existing syntax. Escape a bracket when it should be literal, or put examples inside a code span or fence. A span identifier addresses that point in the note; it does not start a journal page.
 
 ### Alerts
@@ -323,50 +389,51 @@ 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `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` (`NULL` on a zero affix), `zero`, `kind`, `given`, `"where"`, `gloss`, `attaches`, `replaces`, `lengthens`, `front`, `examples`, `barredAfter` and `tones`, then `written`, the form as a table prints it, `∅` for a zero affix.                                                                                                                                                                                                               |
-| `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).                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `register`         | One row per name a language note writes in `data.register`, with its `tongue`, `kind`, `gloss` and `why`, its pieces as `built_text`, and the `notes` carrying the name, derived from the index.                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `tongues`          | One row per tag a language note writes in `data.tongues`: `tag`, `meaning` and `tongue_language`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `retired`          | One row per form a language note writes in `data.retired`: `form`, `instead` as a list, and `why`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `scope`            | One row per value of a language note's `data.scope`: the `kind` it is under and the `value`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `letters`          | One row per entry of a language note's `data.sounds.letters`: `letters` as a list, `kind`, `like`, `place` and `tongue`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `edges`            | One row per entry of a language note's `data.sounds.edges`: the `edge` and its `sounds` as a list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `clusters`         | One row per language note stating `data.sounds.clusters`, with its `max`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `cluster_groups`   | One row per group of a language note's `data.sounds.clusters.groups`: `what`, `clusters` as a list, and `use`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `stress`           | One row per language note stating `data.sounds.stress`, with its `stress`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `finals`           | One row per entry of a language note's `data.sounds.finals`: `final` and `like`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `syllables`        | One row per language note stating `data.sounds.syllables`: each rule a column, the harmony as `harmony_back`, `harmony_front`, `harmony_neutral`, `harmony_neutralAs` and `harmony_partners`, a list of `{ vowel, partner }`.                                                                                                                                                                                                                                                                                                                                                                      |
-| `joining`          | One row per entry of a language note's `data.sounds.joining`: `first`, `second`, `written` and `example`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `joins`            | One row per entry of a language note's `data.sounds.joins`: `meeting`, `rule`, `letters` and `"where"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `marks`            | One row per entry of a language note's `data.sounds.marks`: `mark`, `letters`, `kind` and `"limit"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `skeleton`         | One row per entry of a language note's `data.sounds.skeleton`: `second` and `between`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `frames`           | One row per frame of a language note's `data.sounds.frames`: `frame`, `shape`, `class`, `makes` and `examples` as `{ root, form }`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `read_past`        | One row per entry of a language note's `data.sounds.readPast`: `written`, `readAs` and `what`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `mutations`        | One row per entry of a language note's `data.sounds.mutations`: `mutation`, `sound`, `becomes` and `example`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `sound_changes`    | One row per step of each set in a language note's `data.soundChanges`: the set's `position`, `name`, `from_language`, `to_language` and `takes`, then `step_position`, `step`, `change` and `"where"`.                                                                                                                                                                                                                                                                                                                                                                                             |
-| `elements`         | One row per element of a language note's `data.elements`: `form`, `variants`, `element_position`, `kind`, `sense`, `examples`, `word` and `genitive`.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `roots`            | One row per root of a language note's `data.roots`: `root`, `sense` and `field`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `cognates`         | One row per form of each set in a language note's `data.cognates`: the set's `position`, `gloss` and `proto`, the `form_language` and the `form`.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `calling_names`    | One row per closing of a language note's `data.callingNames`: `form`, `doubled`, `usual` and the language's `min_syllables`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `older`            | One row per form of a language note's `data.older`: `form`, `gloss` and `layer`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `negation`         | One row per language note stating `data.negation`: its `particle` and `mutation`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `name_shapes`      | One row per entry of a language note's `data.naming.shapes`: `of`, `syllables_min`, `syllables_max`, `per_vowel_min` and `per_vowel_max`.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `name_edges`       | One row per entry of a language note's `data.naming.edges`: `edge`, `sounds` as a list, `vowel` and `of`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `name_draws`       | One row per entry of a language note's `data.naming.draws`: `kind` and `elements` as a list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `held_from`        | One row per entry of a language note's `data.naming.heldFrom`: `source`, `takes`, `clip`, and `genitive` and `elements` as lists.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `near_names`       | One row per worked example of a language note's `data.naming.nearName`: `near`, `given` and the language's `min_syllables`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `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`, `terms`, `register`, `tongues`, `retired`, `scope`, `letters`, `edges`, `clusters`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past`, `mutations`, `cluster_groups`, `sound_changes`, `elements`, `roots`, `cognates`, `calling_names`, `older`, `negation`, `name_shapes`, `name_edges`, `name_draws`, `held_from` and `near_names` — 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `names`            | Each authored `.name` span, with its containing NOTE Address, visible text, optional type/subtype and source line/column.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `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` (`NULL` on a zero affix), `zero`, `kind`, `given`, `"where"`, `gloss`, `attaches`, `replaces`, `lengthens`, `front`, `examples`, `barredAfter` and `tones`, then `written`, the form as a table prints it, `∅` for a zero affix.                                                                                                                                                                                                                        |
+| `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 its `cultures` associations. See [dictionaries and glossaries](#dictionaries-and-glossaries).                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `register`         | One row per name a language note writes in `data.register`, with its `tongue`, `kind`, `gloss` and `why`, its pieces as `built_text`, and the `notes` carrying the name, derived from the index.                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `tongues`          | One row per tag a language note writes in `data.tongues`: `tag`, `meaning` and `tongue_language`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `retired`          | One row per form a language note writes in `data.retired`: `form`, `instead` as a list, and `why`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `scope`            | One row per value of a language note's `data.scope`: the `kind` it is under and the `value`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `letters`          | One row per entry of a language note's `data.sounds.letters`: `letters` as a list, `kind`, `like`, `place` and `tongue`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `edges`            | One row per entry of a language note's `data.sounds.edges`: the `edge` and its `sounds` as a list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `clusters`         | One row per language note stating `data.sounds.clusters`, with its `max`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `cluster_groups`   | One row per group of a language note's `data.sounds.clusters.groups`: `what`, `clusters` as a list, and `use`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `stress`           | One row per language note stating `data.sounds.stress`, with its `stress`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `finals`           | One row per entry of a language note's `data.sounds.finals`: `final` and `like`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `syllables`        | One row per language note stating `data.sounds.syllables`: each rule a column, the harmony as `harmony_back`, `harmony_front`, `harmony_neutral`, `harmony_neutralAs` and `harmony_partners`, a list of `{ vowel, partner }`.                                                                                                                                                                                                                                                                                                                                                                               |
+| `joining`          | One row per entry of a language note's `data.sounds.joining`: `first`, `second`, `written` and `example`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `joins`            | One row per entry of a language note's `data.sounds.joins`: `meeting`, `rule`, `letters` and `"where"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `marks`            | One row per entry of a language note's `data.sounds.marks`: `mark`, `letters`, `kind` and `"limit"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `skeleton`         | One row per entry of a language note's `data.sounds.skeleton`: `second` and `between`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `frames`           | One row per frame of a language note's `data.sounds.frames`: `frame`, `shape`, `class`, `makes` and `examples` as `{ root, form }`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `read_past`        | One row per entry of a language note's `data.sounds.readPast`: `written`, `readAs` and `what`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `mutations`        | One row per entry of a language note's `data.sounds.mutations`: `mutation`, `sound`, `becomes` and `example`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `sound_changes`    | One row per step of each set in a language note's `data.soundChanges`: the set's `position`, `name`, `from_language`, `to_language` and `takes`, then `step_position`, `step`, `change` and `"where"`.                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `elements`         | One row per element of a language note's `data.elements`: `form`, `variants`, `element_position`, `kind`, `sense`, `examples`, `word` and `joining`.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `roots`            | One row per root of a language note's `data.roots`: `root`, `sense` and `field`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `cognates`         | One row per form of each set in a language note's `data.cognates`: the set's `position`, `gloss` and `proto`, the `form_language` and the `form`.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `calling_names`    | One row per closing of a language note's `data.callingNames`: `form`, `doubled`, `usual` and the language's `min_syllables`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `older`            | One row per form of a language note's `data.older`: `form`, `gloss` and `layer`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `negation`         | One row per language note stating `data.negation`: its `particle` and `mutation`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `name_shapes`      | One row per entry of a language note's `data.naming.shapes`: `of`, `syllables_min`, `syllables_max`, `per_vowel_min` and `per_vowel_max`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `name_edges`       | One row per entry of a language note's `data.naming.edges`: `edge`, `sounds` as a list, `vowel` and `of`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `name_draws`       | One row per entry of a language note's `data.naming.draws`: `kind` and `elements` as a list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `held_from`        | One row per entry of a language note's `data.naming.heldFrom`: `source`, `takes`, `clip`, and `joining` and `elements` as lists.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `near_names`       | One row per worked example of a language note's `data.naming.nearName`: `near`, `given` and the language's `min_syllables`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `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`, `names`, `words`, `affixes`, `fields`, `glossary`, `language_lineage`, `dictionary`, `terms`, `register`, `tongues`, `retired`, `scope`, `letters`, `edges`, `clusters`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past`, `mutations`, `cluster_groups`, `sound_changes`, `elements`, `roots`, `cognates`, `calling_names`, `older`, `negation`, `name_shapes`, `name_edges`, `name_draws`, `held_from` and `near_names` — 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.
 
@@ -747,11 +814,11 @@ GROUP BY position, gloss ORDER BY position
 ```
 ````
 
-An element's `kind` keeps one set of elements apart from another, and a place's generic gives its `genitive`:
+An element's `kind` keeps one set of elements apart from another, and a place's generic gives its `joining` form:
 
 ````markdown
 ```sql
-SELECT '`' || form || '`' AS "Generic", sense AS "What it names", coalesce('`' || genitive || '`', '—') AS "In the genitive"
+SELECT '`' || form || '`' AS "Generic", sense AS "What it names", coalesce('`' || joining || '`', '—') AS "Joining form"
 FROM elements WHERE language = 'thalorna-note-skill-nordmalng' AND kind = 'place' ORDER BY position
 ```
 ````
@@ -809,7 +876,7 @@ SELECT source AS "held from",
                   WHEN 'element' THEN array_to_string(list_transform(elements, x -> '`' || x || '`'), ', ')
                   ELSE (CASE takes WHEN 'godName' THEN 'that god''s name' ELSE 'that founder''s given name' END)
                        || coalesce(', clipped to its ' || clip || ' element', '')
-                       || coalesce(', with a genitive ' || array_to_string(list_transform(genitive, x -> '`' || x || '`'), ' or '), '')
+                       || coalesce(', with a joining ending ' || array_to_string(list_transform(joining, x -> '`' || x || '`'), ' or '), '')
        END AS "what stands first"
 FROM held_from WHERE language = 'thalorna-note-skill-nordmalng' ORDER BY position
 ```
@@ -840,12 +907,12 @@ See [a language's register, sounds and history](../reference/format-details.md#a
 
 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`, `false` or `only`           | `true`  | Whether a dictionary or a glossary prints its key. `false` leaves it out; `only` prints the key for the fence's rows and no letter or entry, so a page with one `key=false` fence per heading states its key once. Refused on a table. |
-| `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).                                                                              |
+| 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`, `false` or `only`           | `true`  | Whether a dictionary or a glossary prints its key. `false` omits the key and any dictionary verb table; `only` prints the key for the fence's rows and no table, letter or entry. Refused on a table. |
+| `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
 ```sql {allow-empty=true section-level=3}
@@ -873,81 +940,165 @@ See [SQL details](../reference/format-details.md#content-tables) for query optio
 
 ### Dictionaries and glossaries
 
-Two layouts set a result as paragraphs under letter headings rather than as a table. **`layout=dictionary` sets words**, read from the `dictionary` relation: each with its class, its etymology, its senses, numbered where a word's `gloss` lists several, and the notes it is cited from — every note whose prose marks the word in italics. **`layout=glossary` sets terms**, read from the `terms` relation: a culture's or an affiliation's own glossary entries and an affiliation's ranks and offices, each sense tagged with the body or culture it comes from. Each needs the `name`, `senses` and `usage` columns, and a query that leaves one out is reported, naming the column.
-
-**The query decides what appears**, and any note may carry either fence. These are the common ones:
+The build supplies a note's dictionary or glossary from its frontmatter on
+every surface: the site, the Foundry journal and the book.
 
-| What                                      | Layout       | Query                                                                             |
-| ----------------------------------------- | ------------ | --------------------------------------------------------------------------------- |
-| A language's dictionary                   | `dictionary` | `SELECT * FROM dictionary WHERE language = '<the language's Address>'`            |
-| A language's common words, on any page    | `dictionary` | `SELECT * FROM dictionary WHERE language = '<the language's Address>' AND common` |
-| A culture's glossary                      | `glossary`   | `SELECT * FROM terms WHERE list_contains(cultures, '<the culture's Address>')`    |
-| An affiliation's glossary                 | `glossary`   | `SELECT * FROM terms WHERE owner = '<the affiliation's Address>'`                 |
-| The setting's _Dictionary of the Tongues_ | `dictionary` | `SELECT * EXCLUDE (common) FROM dictionary WHERE depth = 0`                       |
-| The setting's _Glossary_                  | `glossary`   | `SELECT * EXCLUDE (common) FROM terms`                                            |
+- **A language note with nonempty `data.words` receives a Dictionary section.** It
+  contains the language's full dictionary as one alphabetical list, with
+  letter headings, each word's field beside it and the key printed once. A
+  language with absent or empty `data.words` receives no Dictionary section.
+- **A culture or affiliation with nonempty `data.glossary` receives a Glossary
+  section.** It contains only the entries that owner declares. Ranks and
+  offices stand in the affiliation's own sections; they enter its glossary
+  only when an explicit glossary entry names them. A note with absent or
+  empty `data.glossary` receives no Glossary section.
 
-A language's dictionary lists the words it inherits through `data.family` beside its own; `depth = 0` lists each word once, under the language that states it. A culture's glossary holds the culture's own terms and the ranks, offices and glossary terms of every affiliation that reaches it. The two setting pages leave out `common`, so they mark no entry: which words are common is a culture's judgement.
+The sections follow the note's authored text. An existing heading with
+`{#dictionary}` or `{#lexicon}` receives the dictionary after its authored
+text; `{#glossary}` does the same for a glossary. The heading and its
+introduction stay in place, with one generated list under it:
 
-The most common Vylari words, on the Vylarian culture's page:
+```markdown
+## Lexicon {#lexicon}
+
+The tongue of Provenzia, whose _solmère_ is its own word.
+```
+
+A dictionary belongs to a language; a glossary belongs to one culture or
+affiliation. A glossary entry belongs for one of three reasons: a common word
+in the owner's core vocabulary, a dictionary word with a context meaning,
+or a phrase, compound or term of art outside the dictionary with its own
+gloss. The [worked culture glossary](../reference/format-details.md#glossary-terms)
+selects `solmère` as a common word, gives `amère` a context meaning and glosses
+`blood-field` as a term outside the dictionary. Its frontmatter supplies the
+whole default Glossary section. There are no setting-wide dictionary or
+glossary pages.
+
+A dictionary noun prints its gender from its existing class and its plural
+where one is available: **marendos** _n. m., pl. marendoi_. An explicit
+word plural wins; otherwise the language's optional `grammar.plural` rule
+replaces the first matching literal ending. The language's optional
+`grammar.verbs` pattern prints once as a small head table, after the key and
+before the letters. Empty verb endings print as "unchanged". Grammar is
+never inherited through `family`, and absent grammar leaves the dictionary
+unchanged. The [worked noun and verb example](../reference/format-details.md#optional-noun-and-verb-forms)
+shows both declarations. Only supplied shapes are checked; words are never
+checked against the rule, and no language must state grammar.
+
+An entry naming a word of its resolved language without a `definition`
+carries the word's dictionary senses and class, with a link to the word's
+entry on its language page. An entry with a `definition` carries that meaning
+instead, retaining its word link and class when it names a dictionary word.
+Ranks, offices and definitions carry their source body or culture beside
+their senses. Common choices belong to each owner: a culture and an
+affiliation using the same language choose independently, and a word may be
+common in one glossary and absent from another. Dictionaries mark nothing
+common.
+
+Public dictionaries omit citations to GM-only notes. `links` checks generated
+tables in the source note's audience: public notes use public rows, and GM
+notes retain GM citations. An authored link from a public note to a GM-only
+note is still reported.
+
+#### Custom views
+
+An `sql` fence with `layout=dictionary` or `layout=glossary` sets a custom view
+of the same relations. A dictionary view reads `dictionary`; a glossary view
+reads `terms`. Each needs the `name`, `senses` and `usage` columns; a query
+that leaves one out is reported, naming the column.
+
+The optional `plural` and `verbs` columns supply noun plurals and the head
+table in a custom dictionary view; `SELECT *` includes both. A projection
+that omits these columns omits that presentation, as omitting `class` omits
+word classes. With the default or `key=true`, each selected language's pattern
+appears once per dictionary result, even when no abbreviation key is needed.
+`key=false` omits both the key and the verb table from a fragment;
+`key=only` prints only the abbreviation key. Separate head-enabled fences
+each print their own tables.
+
+For a custom list of one culture's common entries:
 
 ````markdown
 ## Words Everyone Knows {#common-words}
 
-```sql {layout=dictionary section-level=3}
-SELECT * FROM dictionary WHERE language = 'thalorna-note-skill-vylarilng' AND common
-```
-````
-
-A culture's glossary:
-
-````markdown
-## Glossary {#glossary}
-
 ```sql {layout=glossary section-level=3}
-SELECT * FROM terms WHERE list_contains(cultures, 'thalorna-note-lore-provenzianclt')
+SELECT * FROM terms WHERE owner = 'thalorna-note-lore-provenzianclt' AND common
 ```
 ````
 
-A page that sets several fences, one per heading, states its key once: a `key=only` fence at the head over all the rows the page sets, then `key=false` on each fence below it, so the abbreviations are not repeated under every heading. The `key=only` fence prints the key for its rows and no letter heading and no entry:
+A custom dictionary view can select one field from the language's dictionary:
 
 ````markdown
-## Words {#words}
-
-```sql {layout=dictionary key=only}
-SELECT * FROM dictionary WHERE language = 'thalorna-note-skill-vylarilng' AND depth = 0
-```
-
-### Love and its conduct
+## Love and its conduct
 
-```sql {layout=dictionary key=false section-level=4}
-SELECT d.* FROM dictionary d JOIN words w ON w.language = d.language AND w.form = d.name
-WHERE d.language = 'thalorna-note-skill-vylarilng' AND w.field = 'Love and its conduct'
+```sql {layout=dictionary section-level=3}
+SELECT * FROM dictionary
+WHERE language = 'thalorna-note-skill-provnzlng' AND field = 'Love and its conduct'
 ```
 ````
 
-`key`, whatever its value, sets a dictionary's or a glossary's key, so it is refused on a fence set as a table.
+A custom view with several fences can print its key once: a `key=only` fence
+over all selected rows, then `key=false` on each fence below it. The
+`key=only` fence prints only the abbreviation key. `key`, whatever its value,
+is refused on a fence set as a table. The automatic Dictionary section
+prints its own key once for the full alphabetical list.
 
 Either layout prints, in order:
 
-- **a key**, once, unless the fence sets `key=false`, and nothing else where it sets `key=only`, 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.
+- **a key**, once, unless the fence sets `key=false`, and nothing else where
+  it sets `key=only`, listing the abbreviations the result uses — a language's
+  tag, a word's class or a modifier — each with its expansion; a glossary also
+  explains 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**: a glossary's `•` for a common entry, the
+  headword in bold, its pronunciation between slashes, its language tag and
+  word class in italics where present, its senses, and after a dash the notes
+  it is cited from, as links.
 
-A word also carries its class beside the tag and its etymology in brackets:
+A dictionary entry gives its field in italic parentheses and its etymology
+in brackets:
 
 ```markdown
-• **solmère** /sol-MEH-reh/ _n. m._ [fr. Élav. _sólmerë_] Longing; the ache for a time that is gone. — [[thalorna-note-lore-lastshrine|The Song of the Last Shrine]]
+**solmère** /sol-MEH-reh/ _n. m._ (_Love and its conduct_) [fr. Élav. _sólmerë_] Longing; the ache for a person, a place or a time that is gone. — [[thalorna-note-lore-lastshrine|The Song of the Last Shrine]]
 ```
 
-A term carries no class, and each of its senses names its source. A glossary sets the rows sharing a headword and a language as one entry, numbering their senses in the order the rows arrive and printing a sense several bodies give once, with all of them:
+A glossary entry naming a dictionary word uses the word's senses when
+`definition` is absent; a list of dictionary glosses supplies every sense.
+Those senses carry no body label. An entry with a `definition` uses that
+meaning and labels it with the owner, retaining its word link and class
+where it names a dictionary word. On the owner's own page, a sense attributed
+only to that owner omits the repeated label; other bodies and shared senses
+keep their labels. A glossary sets the rows sharing a headword
+and a language as one entry, numbering their senses in query order and
+printing a sense several bodies give once, with all of them:
 
 ```markdown
-**Sworn Knight** **1** (_Duchy of Aubrac_) Holds land of the duke. **2** (_Kingdom of Provenzia_) Holds land of the crown. **3** (_Provenzia_) A knight bound by oath to a lord. — [[thalorna-note-affiliation-duchy|Duchy of Aubrac]], [[thalorna-note-affiliation-kingdom|Kingdom of Provenzia]], [[thalorna-note-lore-provenzianclt|Provenzia]]
-```
-
-The entries are ordered by the layout, not by the query: by letter, then by `name_sort`. **The language tag prints where the entry's language is not the page's own**: a language note's own language, a culture's `data.language`, or the language an affiliation's glossary resolves to. It is the language note's `data.abbreviation`, or its full name where it states none. The etymology never repeats the entry's own language: a borrowed word prints `[fr. Élav. _sólmerë_]`, a built word its pieces each with its gloss, `[_am-_ "love" + _-ère_ "one who"]`, an inherited word its older form, `[*_hur_]` or `[Hel. *_thalass_]`, and a root word its root and pattern. A citation of a note with no published page prints as its name.
-
-A culture's or an affiliation's `data.glossary` shapes both: an entry without a definition marks a word or a rank common, gives it a sort key or a respelling, and lets in a rank whose title is a single word; an entry with a definition replaces the senses of the owner's own rank or office, or is a term of the owner's own. The [format reference](../reference/format-details.md#dictionaries-and-glossaries) gives every column and rule.
+**Sworn Knight** **1** (_Duchy of Aubrac_) Holds land of the duke. **2** (_Kingdom of Provenzia_) Holds land of the crown. **3** A knight bound by oath to a lord. — [[thalorna-note-affiliation-duchy|Duchy of Aubrac]], [[thalorna-note-affiliation-kingdom|Kingdom of Provenzia]], [[thalorna-note-lore-provenzianclt|Provenzia]]
+```
+
+The layout orders entries by letter, then by `name_sort`. **The language tag
+prints where the entry's language is not the page's own**: a language note's
+own language, a culture's `data.language`, or the language an affiliation's
+glossary resolves to. It is the language note's `data.abbreviation`, or its
+full name where unstated. Etymology never repeats the entry's own language:
+a borrowed word prints `[fr. Élav. _sólmerë_]`, a built word its pieces each
+with its gloss, `[_am-_ "love" + _-ère_ "one who"]`, an inherited word its
+older form, `[*_hur_]` or `[Hel. *_thalass_]`, and a root word its root and
+pattern. A citation of a note with no published page prints as its name.
+
+A built piece can name a language element by its `form` or one of its
+`variants`; its `sense` prints beside the piece. An affix can also be named by
+its `front` form. Words and affixes take precedence over elements in the same
+language, and the language is searched before its ancestors. Exact spellings
+are checked before ignoring joining hyphens; case and accents are preserved.
+
+A glossary entry may give its own sort key or respelling. A reference to a
+rank or office inherits its descriptions and admits a title of one word; its
+`common` value belongs to the entry's owner. A definition replaces the senses
+of the owner's own rank or office, or supplies an entry of the owner's own.
+The [format reference](../reference/format-details.md#dictionaries-and-glossaries)
+gives every column and rule.
 
 ## Page lists
 
@@ -987,7 +1138,7 @@ That list names the `lore` notes tagged `key-concept`, grouped by type and alpha
 
 **A tag no page carries is a finding** at the fence's own line, naming the tag it looked for. A misspelled tag is the whole of what goes wrong here, and a heading with an empty list under it is how one goes unnoticed. Write `{allow-empty=true}` where a group that is genuinely empty is intended; the directive then leaves nothing behind rather than an empty list.
 
-A page list names this package's own pages. A **stub** — a note with an empty body — publishes no page, so it joins no list. A note tagged `gm` is listed in Foundry and left out of the website and the book, exactly as it is left out of a content table's relations.
+A page list names this package's own pages. A **stub** — a note with neither an authored body nor automatic lexical content — publishes no page, so it joins no list. A note tagged `gm` is listed in Foundry and left out of the website and the book, exactly as it is left out of a content table's relations.
 
 See [page-list details](../reference/format-details.md#page-lists) for the directive's full behaviour.