@heroiclands/package-build 23.13.0 → 24.0.1

package/docs/reference/format-details.md

@@ -492,8 +492,7 @@ The event fell on {{dateformat "vrcal" "300.25"}}.
 The comparison helpers `gt`, `gte`, `lt`, and `lte` take two numbers; `eq`
 compares two values. `and`, `or`, and `not` combine Boolean results. Nested
 helpers use Handlebars parentheses. These expressions are replaced on web,
-Foundry, and book pages. Code spans and fences remain literal, as do Hugo
-shortcodes such as `{{< glyph slug="bes" >}}`. Prefix `\{{` to show an
+Foundry, and book pages. Code spans and fences remain literal. Prefix `\{{` to show an
 expression literally in prose. A missing property, unresolved
 calendar, or invalid date produces a located build error.
 
@@ -2015,7 +2014,8 @@ generic families are not checked. `input`, `layout` and `encoding` in
 Text marked with `font=` or `map=`, or with a declared language, is plain: a
 span or a verse holds no emphasis, link, image, footnote, wikilink, code or
 HTML, and no span but a marked one inside a div or a fence; a div holds
-paragraphs and line breaks only. The text is read as written, so `[`, `]`, `"`,
+paragraphs and line breaks only. Text set in a face takes `*…*` and `**…**`,
+set by its [emphasis convention](#script-notes-and-emphasis). The text is read as written, so `[`, `]`, `"`,
 `<<`, `>>`, `!` and `@#$%^&` are characters, and a bracket pair is markup only
 when `(`, `{` or a second `[` makes it a link, a span or a wikilink. Text marked
 with a real language's tag alone keeps its Markdown. See
@@ -2054,12 +2054,13 @@ data:
       - { from: y, to: "\U000F0246", before: consonant }
 ```
 
-| Key      | Shape                                                | Meaning                                                                         |
-| -------- | ---------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `name`   | string, required                                     | What `map=` names it by: lowercase letters, digits and `-`, unique in the index |
-| `vowels` | string                                               | The characters `before: vowel` reads as vowels                                  |
-| `fonts`  | list of `{ font, rows? }`, required, at least one    | The faces the map is drawn in, by slug, each with any rows of its own           |
-| `rows`   | list of `[from, to]` or `{ from, to, before?, at? }` | The shared rewrites, in authored order                                          |
+| Key           | Shape                                                | Meaning                                                                         |
+| ------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------- |
+| `name`        | string, required                                     | What `map=` names it by: lowercase letters, digits and `-`, unique in the index |
+| `logographic` | `true`                                               | The script writes meanings; see [a logographic map](#a-logographic-map)         |
+| `vowels`      | string                                               | The characters `before: vowel` reads as vowels                                  |
+| `fonts`       | list of `{ font, rows? }`, required, at least one    | The faces the map is drawn in, by slug, each with any rows of its own           |
+| `rows`        | list of `[from, to]` or `{ from, to, before?, at? }` | The shared rewrites, in authored order                                          |
 
 **A face's own rows come first.** A run in a face tries that face's `rows`,
 the longest match among them, and only where none matches the shared `rows`; a
@@ -2116,6 +2117,8 @@ The map's own check reports the rest, each at its key:
 
 > `` `data.map.fonts[0].font` is `mono`, a generic family; a map lists the faces it is drawn in ``
 
+> `` `data.map.rows[2]` matches `z`, a letter, and the rows of a logographic map write only the text between words ``
+
 The lint checks the listed faces against the installed `@heroiclands/fonts`,
 each at the entry or the row at fault. Every listed face draws every code point
 its own rows write, every code point the shared rows it can reach write (a
@@ -2230,6 +2233,203 @@ every word with its native form, through the same code as the build: see
 [`transliterate`](../commands.md#package-build-transliterate-map-text) and
 [`lexicon`](../commands.md#package-build-lexicon-language).
 
+#### Metres
+
+A verse fence that states `scan=` is counted against a metre declared in a
+`doc` note's `data.metres`, each entry `{ name, beats, kind }`. `name` is
+lowercase letters, digits and `-`, unique in the package, and a name declared
+twice is an error at the second. `beats` is a whole number above zero. `kind` is
+`accentual`: a beat falls on a stressed syllable, and no syllable's length is
+counted.
+
+The fence states `lang=` with a language whose `note` names a language note
+stating `data.sounds.stress` (see [a language's register, sounds and
+history](#a-languages-register-sounds-and-history)). A word has one beat on its
+stressed syllable when it has two or more syllables; a one-syllable word has a
+beat when the `class` base of its lexicon entry is `n`, `v`, `adj`, `num` or
+`name`, and none when it is any other base; a one-syllable word the lexicon
+does not hold is counted as a content word; a word whose entries differ in
+class is a beat that may be left out; and a word of four or more syllables
+whose stress is not on its first may take a second beat there. A line scans when
+its count can be the metre's.
+
+| Finding                                                                                         | Severity |
+| ----------------------------------------------------------------------------------------------- | -------- |
+| A line whose beats cannot be the metre's, at the line                                           | warning  |
+| A `scan=` no `data.metres` entry names, at the value                                            | error    |
+| A `scan=` on a fence with no `lang=`, at the key                                                | error    |
+| A `scan=` on a fence whose language states no stress rule or names no language note, at `lang=` | error    |
+| A `scan=` on a verse in columns, at the key                                                     | error    |
+
+> ``this line has 4 beats (5 with secondary beats); the metre `hexameter` has 6``
+
+The count is an author-side check. The rendered fence carries `data-scan` with
+the metre's name and nothing a reader sees.
+
+#### A logographic map
+
+A map stating `logographic: true` writes meanings, so its rows spell no word.
+Every word of a run under it is written from the run language's lexicon, and
+the rows write only the text between words: whitespace, points and any other
+text holding no letter. A word holds at least one letter; a run of digits is
+text between words. A word is matched case folded, NFC, with `’` read as `'`,
+and written by the first of these that gives a writing:
+
+1. **The entries of its form.** Each entry whose `form`, folded, is the word,
+   and failing that each whose folded `form` with its joining hyphens taken
+   off is the word (`Gar-` for `gar`). An entry is written by its own `native`
+   for the map, the one for the run's face where it states one, else the one
+   for no face; else by its `built` pieces' writings joined in order.
+2. **A derived form.** A noun's plural (its own `plural`, else the
+   `data.grammar.plural` rule) and a verb's present form for one person of
+   `data.grammar.verbs.persons` are written by the stem's entry's writing,
+   followed by the `text` of the `data.grammar.native` entry for that ending.
+   Other derived forms (a replacing suffix, an agreeing form, a participle)
+   have no writing of their own here; they are coined as words, or written in
+   signs.
+3. **Its hyphenated parts.** A word holding a hyphen or an en dash that the
+   steps above do not write is written by each part in turn, each by steps 1
+   and 2; the hyphen writes nothing.
+
+A `built` piece is a word of the lexicon written exactly as the piece, else an
+affix of `data.affixes` whose `form` or `front` is the piece, else either one
+with joining hyphens taken off; a word piece is written by its own `native` or
+its own pieces, recursively, and an affix by its own `native`. A piece that
+reaches a word already being resolved has no writing.
+
+**Ambiguity.** Where a step matches more than one entry and their writings are
+not all one text, or one has a writing and another none, the word has no
+writing and is an error naming every entry's gloss. A part matched that way
+makes the word ambiguous the same way, naming the part.
+
+| Key                            | Shape                                                   | Meaning                                                 |
+| ------------------------------ | ------------------------------------------------------- | ------------------------------------------------------- |
+| `data.affixes[].native`        | list of `{ map, font?, text }`                          | The affix's writing, for a `built` piece naming it      |
+| `data.grammar.native`          | list of `{ ending, map, font?, text }`                  | The signs a derived form takes after its stem's writing |
+| `data.grammar.native[].ending` | `plural`, `I`, `you`, `heShe`, `we`, `youAll` or `they` | The ending written                                      |
+| `data.grammar.native[].text`   | string, required, may be empty                          | The ending's signs; empty writes the stem alone         |
+
+```yaml
+affixes:
+  - form: "-unet"
+    gloss: "a thing made of"
+    native:
+      - { map: zethu, text: "\U0001EBC7" }
+grammar:
+  plural:
+    - { ending: "", becomes: "im" }
+  verbs:
+    persons: { I: en, you: et, heShe: "", we: enu, youAll: etu, they: ar }
+  native:
+    - { ending: plural, map: zethu, text: "\U0001EBE1" }
+    - { ending: I, map: zethu, text: "\U0001EBDF" }
+```
+
+A word with no writing, an ambiguous word, and a word in a run with no lexicon
+to write it from are each an error at the word, once per run:
+
+> `` `zamlu` has no `zethu` writing in the `khel` lexicon, and its parts do not give one; state one, or write the word directly in signs ``
+
+> `` `nelgir` stands for 2 words of the `khel` lexicon that the map `zethu` writes differently, “a god” and “god”; write the word directly in signs, choosing by its sense in `package-build lexicon khel --map zethu` ``
+
+> `` `Gar-nelgir` is written from its part `nelgir`, which stands for 2 words of the `khel` lexicon that the map `zethu` writes differently, “a god” and “god”; write the word directly in signs, choosing by its sense in `package-build lexicon khel --map zethu` ``
+
+> `` `halzi` has no `zethu` writing: the map `zethu` is logographic, and the run names no `lang=` whose lexicon writes it; mark the run with its language, or write the word directly in signs ``
+
+> `` `halzi` has no `zethu` writing: the map `zethu` is logographic, and `tant` has no lexicon (`languages.tant.note`) to write it from; write the word directly in signs ``
+
+Signs typed in the run hold no letter, so they are no word and pass through as
+typed. The face-coverage check reads the writings as it reads native forms; a
+word with no writing is reported by its own finding alone. The lexicon check
+and the register check apply to the run as to any mapped run.
+
+Under a logographic map a word's `native` is its writing and is not compared
+with the rows. An affix's `native` and `data.grammar.native` are read only by
+a logographic map, so an entry naming any other map is an error, as is an
+ending of a person where the pattern states no `persons`. The checks of a
+word's `native` (an unknown map, a face the map is not for, a second entry, an
+undrawn code point) apply to both, a second entry being one for the same
+ending, map and face:
+
+> `` `data.affixes[0].native[0]` names the map `roman`, which is not logographic; an affix is written by a native form only under a logographic map ``
+
+> `` `data.grammar.native[0]` names the map `roman`, which is not logographic; an ending is written by a native form only under a logographic map ``
+
+> `` `data.grammar.native[2]` states a second native form of the ending `plural` for the map `zethu`; the first is `data.grammar.native[1]` ``
+
+> `` `data.grammar.native[3]` writes the ending `they`, and `data.grammar.verbs` states no `persons` ``
+
+Affix and ending writings are not rows of the `natives` relation, which holds
+the words' native forms; `package-build lexicon` resolves them.
+
+#### Script notes and emphasis
+
+A `skill` note of `subType: script` states the faces its script is written in
+and how the script marks a stressed word, in `data.script`:
+
+```yaml
+data:
+  script:
+    fonts: [qalezu-hand]
+    emphasis: overline
+    strongEmphasis: rubric
+```
+
+- **`fonts`** lists installed faces by the slug `font=` names them by, at least
+  one. A face belongs to one script.
+- **`emphasis`** is `rubric` or `overline`, and sets both `*…*` and `**…**`
+  (or `_…_` and `__…__`) inside a run in one of the faces.
+- **`strongEmphasis`**, optional, is `rubric` or `overline`, and sets `**…**`
+  alone.
+
+A `skill` note of `subType: language` may state `data.emphasis`: `words`,
+`rubric` or `overline`. It overrides the script's convention in every run of the
+language. `words` means the language marks emphasis with a word, so `*…*` or
+`**…**` in a run of the language is an error at the emphasis.
+
+Inside a run in a face, `_…_` is emphasis equal to `*…*`, and `__…__` equal to
+`**…**`; Markdown reads them as the same emphasis, and a formatter writes the
+underscore form. A strikethrough is an error.
+
+A run's convention is its `lang=` language's `data.emphasis`, read through
+[`languages.<name>.note`](../configuration.md#languages); else the
+`data.script` of the script note listing its face; else none. Each convention
+renders as:
+
+| Convention | Site and Foundry                                                 | Book                          |
+| ---------- | ---------------------------------------------------------------- | ----------------------------- |
+| `rubric`   | `<em class="emph-rubric">` or `<strong class="emph-rubric">`     | `#text(fill: book-rubric)[…]` |
+| `overline` | `<em class="emph-overline">` or `<strong class="emph-overline">` | `#overline[…]`                |
+| none       | `<em>` or `<strong>`, no class                                   | the text alone                |
+
+Inside a face's run, the element keeps the face's Regular: `font-synthesis:
+none`, with no slant and no added weight. The two classes and the rubric's
+colour are described in [the theme](theme-pages.md#emphasis-in-a-script).
+
+Each of these is an error at the key or the entry at fault:
+
+> `` `data.script.emphasis` should be `rubric` or `overline`, but reads "rubrik". Did you mean "rubric"? ``
+
+> `` `data.script` states a script's faces and emphasis, and this note's `subType` is not `script` ``
+
+> `` `data.emphasis` states how a language marks emphasis, and this note's `subType` is not `language` ``
+
+> `` `data.script.fonts` is empty; a script lists each face it is written in ``
+
+> `` `data.script.fonts[0]` is `serif`, a generic family; a script lists the faces it is written in ``
+
+> `` `data.script.fonts[1]` lists the font `semaron-kuriale` a second time; the first is `data.script.fonts[0]` ``
+
+> `` `data.script.fonts[0]` is `semaron-kuriale`, which Skills/Scripts/Semaron_Carved.md also lists; a face belongs to one script ``
+
+> `` `qalezu-hnad` is not a font: `data.script.fonts[1]` names an installed face; did you mean `qalezu-hand`? ``
+
+In a run:
+
+> ``text marked `lang=prv font=semaron-kuriale map=semaron` takes emphasis only as `*…*`, `_…_`, `**…**` or `__…__` ``
+
+> `` `vyl` marks emphasis with a word, not a mark; write the word ``
+
 ### Assets are types
 
 `icon`, `image` and `audio` are types in the type vocabulary, and an address
@@ -3349,7 +3549,7 @@ for the keys.
 | `letters`        | `data.sounds.letters`           | `letters` (a list), `kind`, `like`, `place`, `tongue` (a list, `NULL` for every tongue)                                                                                                                                                                                                                                                                                    |
 | `edges`          | `data.sounds.edges`             | `edge`, `sounds` (a list: `[any]` for every sound, empty for none)                                                                                                                                                                                                                                                                                                         |
 | `clusters`       | `data.sounds.clusters`          | No `position`: `max`, one row per language stating it                                                                                                                                                                                                                                                                                                                      |
-| `stress`         | `data.sounds.stress`            | No `position`: `stress`, one row per language stating it                                                                                                                                                                                                                                                                                                                   |
+| `stress`         | `data.sounds.stress`            | No `position`: `two`, `longer` and `mark` (`NULL` where unstated), one row per language stating it                                                                                                                                                                                                                                                                         |
 | `finals`         | `data.sounds.finals`            | `final`, `like`                                                                                                                                                                                                                                                                                                                                                            |
 | `syllables`      | `data.sounds.syllables`         | No `position`, one row per language stating it: `onsets`, `codas`, `finals`, `doubled`, `vowelPairs`, `neverInitial` and `signature` (lists, `any` a list of one), `initialVowel` and `finalVowel` (`true` or `false`), and the harmony as `harmony_back`, `harmony_front`, `harmony_neutral`, `harmony_neutralAs` and `harmony_partners` (a list of `{ vowel, partner }`) |
 | `joining`        | `data.sounds.joining`           | `first` and `second` (lists), `written`, `example`                                                                                                                                                                                                                                                                                                                         |
@@ -5881,242 +6081,261 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 - combat
 - combattechnique
 
-| `data` property                            | Values                                                                                                                         | Description                                                                                                                                                                          |
-| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `templatePriority`                         | `number`                                                                                                                       | Template priority, _null_ = not a template                                                                                                                                           |
-| `masteryLevel`                             | `number`                                                                                                                       | HM3 mastery level                                                                                                                                                                    |
-| `parentSkill`                              | `Address`                                                                                                                      | Parent skill this skill specializes                                                                                                                                                  |
-| `names`                                    | `{ pattern, given, <name>... }`                                                                                                | `language` only: how its speakers are named, for `package-build npc new` — see [name lists](#name-lists)                                                                             |
-| `names.pattern`                            | `string`, `string[]` or map of `gender` words to either, required                                                              | Placeholders such as `{given}`, `{given.male}` and `{clan}`, each naming a list, with literal text around them; a list states several forms, a map each gender's forms               |
-| `names.given`                              | map of `gender` words to lists of names, required                                                                              | Given names by gender; `female` and `male` are required                                                                                                                              |
-| `names.given.<name>`                       | `string[]`                                                                                                                     | The given names of one gender                                                                                                                                                        |
-| `names.<name>`                             | `string[]`                                                                                                                     | A list the placeholder of the same name draws from                                                                                                                                   |
-| `family`                                   | `Address`                                                                                                                      | `language` only: the parent language, naming a skill note with `subType: language`; this language reads the parent's words as its own — see [a language's words](#a-languages-words) |
-| `abbreviation`                             | `string`                                                                                                                       | `language` only: the tag a dictionary prints for it, as `Prov.`; its full name where unstated — see [dictionaries and glossaries](#dictionaries-and-glossaries)                      |
-| `grammar`                                  | `{ plural?, verbs?, agreement?, participles? }`                                                                                | Optional noun plurals, one verb pattern, agreement and participles; supplied shapes only are checked                                                                                 |
-| `grammar.plural`                           | `{ ending, becomes }[]`                                                                                                        | Literal suffix replacements in authored order; the first match wins                                                                                                                  |
-| `grammar.plural[].ending`                  | `string`, required, may be empty                                                                                               | Bare suffix to replace; empty matches every noun                                                                                                                                     |
-| `grammar.plural[].becomes`                 | `string`, required, may be empty                                                                                               | Bare replacement; empty deletes the matching suffix                                                                                                                                  |
-| `grammar.verbs`                            | `{ invariant: true }` or `{ persons: { I, you, heShe, we, youAll, they }, replaces? }`                                         | One regular present pattern, printed once at the dictionary head                                                                                                                     |
-| `grammar.verbs.invariant`                  | `true`                                                                                                                         | Verbs do not change; excludes `persons`                                                                                                                                              |
-| `grammar.verbs.persons`                    | a map of all six ending strings                                                                                                | Each ending is added to the citation form, or replaces its closing `replaces`; excludes `invariant`                                                                                  |
-| `grammar.verbs.persons.I`                  | `string`, required, may be empty                                                                                               | Ending for I                                                                                                                                                                         |
-| `grammar.verbs.persons.you`                | `string`, required, may be empty                                                                                               | Ending for you                                                                                                                                                                       |
-| `grammar.verbs.persons.heShe`              | `string`, required, may be empty                                                                                               | Ending for he/she                                                                                                                                                                    |
-| `grammar.verbs.persons.we`                 | `string`, required, may be empty                                                                                               | Ending for we                                                                                                                                                                        |
-| `grammar.verbs.persons.youAll`             | `string`, required, may be empty                                                                                               | Ending for you all                                                                                                                                                                   |
-| `grammar.verbs.persons.they`               | `string`, required, may be empty                                                                                               | Ending for they                                                                                                                                                                      |
-| `grammar.verbs.replaces`                   | `string`, nonempty                                                                                                             | Closing letters each ending takes the place of; a citation form closing otherwise takes the ending whole. With `persons` only                                                        |
-| `grammar.agreement`                        | `{ classes, endings }`                                                                                                         | Adjectives, pronouns or any other named classes agree by swapping among `endings`; see [optional noun and verb forms](#optional-noun-and-verb-forms)                                 |
-| `grammar.agreement.classes`                | `string[]`, required, at least one                                                                                             | Word class bases from the [master word classes](#word-classes), each once                                                                                                            |
-| `grammar.agreement.endings`                | `string[]`, required, at least two                                                                                             | The singular endings, one per gender; the `plural` rule gives each one's plural                                                                                                      |
-| `grammar.participles`                      | `{ root, affixes }`                                                                                                            | Participle suffixes on the verb root; see [optional noun and verb forms](#optional-noun-and-verb-forms)                                                                              |
-| `grammar.participles.root`                 | `string[]`, required, at least one, nonempty                                                                                   | Infinitive endings a citation form drops to give the root; the longest that fits wins                                                                                                |
-| `grammar.participles.affixes`              | `string[]`, required, at least one                                                                                             | Suffixes of `affixes`, by `form`, each attaching to the root as its `replaces` says                                                                                                  |
-| `classModifiers`                           | `string[]`                                                                                                                     | `language` only: the word class modifiers the language uses, each from the [master word classes](#word-classes); empty when unstated                                                 |
-| `fields`                                   | `{ name, holds }[]`                                                                                                            | `language` only: the fields its words are grouped under                                                                                                                              |
-| `fields[].name`                            | `string`, required                                                                                                             | The field's name, which a word's `field` names                                                                                                                                       |
-| `fields[].holds`                           | `string`, required                                                                                                             | What the field holds                                                                                                                                                                 |
-| `words`                                    | `{ form, class, field, gloss, … }[]`                                                                                           | `language` only: its words in authored order; its automatic dictionary sorts them alphabetically — see [a language's words](#a-languages-words)                                      |
-| `words[].form`                             | `string`, required                                                                                                             | The word as cited, bare: no backticks                                                                                                                                                |
-| `words[].variants`                         | `string[]`                                                                                                                     | Its other forms, as a short form beside a long one; a marked use of one cites the word                                                                                               |
-| `words[].name_sort`                        | `string`                                                                                                                       | Its sort key; the form when unstated                                                                                                                                                 |
-| `words[].class`                            | `string`, required                                                                                                             | A class from the master word classes, base first: `n I f`                                                                                                                            |
-| `words[].plural`                           | `string`                                                                                                                       | Optional explicit noun plural; the dictionary uses it before the language rule                                                                                                       |
-| `words[].field`                            | `string`, required                                                                                                             | One of the note's `fields` names                                                                                                                                                     |
-| `words[].gloss`                            | `string` or `string[]`, required                                                                                               | The meaning, in brief; a list states one sense per entry, which a dictionary numbers                                                                                                 |
-| `words[].source`                           | `{ kind, language?, form? }`                                                                                                   | Where the word comes from                                                                                                                                                            |
-| `words[].source.kind`                      | `inherited`, `borrowed`, `kept`, `worn`, `coined`, `substrate` or `island`, required                                           | How the word came into the language                                                                                                                                                  |
-| `words[].source.language`                  | `Address`                                                                                                                      | The language a `borrowed` word came from, naming a skill note with `subType: language`; required for `borrowed`                                                                      |
-| `words[].source.form`                      | `string`                                                                                                                       | The form the word had in its source, bare                                                                                                                                            |
-| `words[].built`                            | `string[]`                                                                                                                     | The pieces the word is built from, in order, as the note's words and affixes write them; absent for a root word                                                                      |
-| `words[].note`                             | `string`                                                                                                                       | What a source says of the word beyond its pieces, as a cognate it is read with                                                                                                       |
-| `words[].pronunciation`                    | `string`                                                                                                                       | A respelling, as `sol-MEH-reh`: letters, apostrophes and hyphens, at most one syllable in capitals                                                                                   |
-| `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, named in `sounds.frames` of the language or an ancestor                                                                                                  |
-| `words[].native`                           | `{ map, font?, text }[]`                                                                                                       | The word's native form under a map, stated only where the rows spell it differently — see [a map reads the dictionary first](#a-map-reads-the-dictionary-first)                      |
-| `words[].native[].map`                     | `string`                                                                                                                       | Required: the `data.map.name` the form is written for                                                                                                                                |
-| `words[].native[].font`                    | `string`                                                                                                                       | The one face the form is for, one the map lists; unstated, every face it lists                                                                                                       |
-| `words[].native[].text`                    | `string`                                                                                                                       | Required: the word as the script writes it                                                                                                                                           |
-| `affixes`                                  | `{ form?, zero?, kind?, given?, where?, gloss, attaches?, examples?, barredAfter?, tones? }[]`                                 | `language` only: the affixes a word's `built` pieces may name; each states a `form` or `zero: true`                                                                                  |
-| `affixes[].form`                           | `string`                                                                                                                       | The affix as a `built` piece names it, as `-rith`; absent on a zero affix                                                                                                            |
-| `affixes[].zero`                           | `boolean`                                                                                                                      | The affix is written as nothing, as a case with no ending; it states no `form`, prints as `∅`, and no `built` piece names it                                                         |
-| `affixes[].kind`                           | `case`, `derivation`, `tense`, `aspect`, `mood`, `voice`, `name` or `lineage`                                                  | What it makes: a case, a derived word, a verb's tense, aspect, mood or voice, a given name's ending or a lineage name's ending                                                       |
-| `affixes[].given`                          | `man`, `woman` or `either`                                                                                                     | Who a given name closing on it belongs to; only on an affix of kind `name`                                                                                                           |
-| `affixes[].where`                          | `string`                                                                                                                       | Where this form stands, for an affix written two ways, as `before a stop`; everywhere where absent                                                                                   |
-| `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[].barredAfter`                    | `string[]`                                                                                                                     | The sounds a stem may not close on to take the affix, as `[n]`                                                                                                                       |
-| `affixes[].tones`                          | `string`                                                                                                                       | The tone pattern it carries, as `L`                                                                                                                                                  |
-| `affixes[].replaces`                       | `string`                                                                                                                       | What it takes the place of at the close of the stem: `vowel` for any closing vowel, or the letters, as `a`; added to the whole stem where absent                                     |
-| `affixes[].attachesTo`                     | `string[]`                                                                                                                     | The word classes it attaches to, by their base, as `[n, adj]`; every class where absent                                                                                              |
-| `affixes[].lengthens`                      | `boolean`                                                                                                                      | Whether the stem's last vowel lengthens before it; `false` where unstated, and never beside `replaces`                                                                               |
-| `affixes[].front`                          | `string`                                                                                                                       | Its form after front vowels, where the language keeps vowel harmony, as `-ür`                                                                                                        |
-| `tongues`                                  | `{ tag, meaning, language? }[]`                                                                                                | `language` only: the tags a register row's `tongue` names — see [a language's register, sounds and history](#a-languages-register-sounds-and-history)                                |
-| `tongues[].tag`                            | `string`, required                                                                                                             | Lowercase letters and digits, as `dunhari`, or a tag closing on `:<tongue>`, as `exonym:<tongue>`, which declares `exonym:vylari` and every tag like it                              |
-| `tongues[].meaning`                        | `string`, required                                                                                                             | What a name of this tongue is                                                                                                                                                        |
-| `tongues[].language`                       | `Address`                                                                                                                      | The language note the tag names, where it is one                                                                                                                                     |
-| `register`                                 | `{ name, tongue?, kind?, built?, why? }[]`                                                                                     | `language` only: every name the setting gives in the language's reach; the notes carrying each are derived                                                                           |
-| `register[].name`                          | `string`, required                                                                                                             | The name, as the setting writes it                                                                                                                                                   |
-| `register[].tongue`                        | `string`                                                                                                                       | A tag `tongues` declares, or `translation`; a row states a `tongue`, a `kind`, or both                                                                                               |
-| `register[].kind`                          | `byname`, `given` or `place`                                                                                                   | What kind of name it is, in a language that sorts its names by kind                                                                                                                  |
-| `register[].built`                         | `string[]`                                                                                                                     | The pieces the name is built from, as a word's `built` writes them                                                                                                                   |
-| `register[].gloss`                         | `string`                                                                                                                       | What the name means, where the pages give its sense                                                                                                                                  |
-| `register[].why`                           | `string`                                                                                                                       | Why the name stands outside the pattern the language's names are built by                                                                                                            |
-| `retired`                                  | `{ form, instead?, why }[]`                                                                                                    | `language` only: the forms the setting does not write                                                                                                                                |
-| `retired[].form`                           | `string`, required                                                                                                             | The form the setting does not write                                                                                                                                                  |
-| `retired[].instead`                        | `string` or `string[]`                                                                                                         | What is written in its place; absent where nothing is                                                                                                                                |
-| `retired[].why`                            | `string`, required                                                                                                             | Why the setting does not write it                                                                                                                                                    |
-| `scope`                                    | `{ folders?, cultures?, lore?, parents?, addresses?, paths?, types?, skip? }`                                                  | `language` only: the notes the register covers                                                                                                                                       |
-| `scope.folders`                            | `Address[]`                                                                                                                    | Every note whose `packFolder` is one of these folders                                                                                                                                |
-| `scope.cultures`                           | `Address[]`                                                                                                                    | Every note whose `culture` is one of these cultures                                                                                                                                  |
-| `scope.lore`                               | `Address[]`                                                                                                                    | Every note whose `lore` names one of these notes                                                                                                                                     |
-| `scope.parents`                            | `Address[]`                                                                                                                    | Every note whose `parents` names one of these notes                                                                                                                                  |
-| `scope.addresses`                          | `Address[]`                                                                                                                    | These notes themselves                                                                                                                                                               |
-| `scope.paths`                              | `string[]`                                                                                                                     | Every note whose file sits below one of these content paths, as `Regions/Aelwyth/`                                                                                                   |
-| `scope.types`                              | `string[]`                                                                                                                     | The note types covered; a note of another type is out of scope whatever else catches it                                                                                              |
-| `scope.skip`                               | `Address[]`                                                                                                                    | Notes out of scope whatever else catches them                                                                                                                                        |
-| `sounds`                                   | `{ letters?, edges?, clusters?, stress?, finals?, syllables?, joining?, joins?, marks?, skeleton?, frames?, readPast? }`       | `language` only: the letters it writes and the rules its words keep                                                                                                                  |
-| `sounds.letters`                           | `{ letters, kind, like?, place?, tongue? }[]`                                                                                  | The letters and the sounds they stand for                                                                                                                                            |
-| `sounds.letters[].letters`                 | `string[]`, required                                                                                                           | The letters or digraphs the row describes                                                                                                                                            |
-| `sounds.letters[].kind`                    | `string`, required                                                                                                             | What kind of sound they write, as `consonant` or `long vowel`                                                                                                                        |
-| `sounds.letters[].like`                    | `string`                                                                                                                       | What they sound like; absent where the row states only their kind and place                                                                                                          |
-| `sounds.letters[].place`                   | `string`                                                                                                                       | Where in the mouth they are made, as `lips` or `tongue-tip`                                                                                                                          |
-| `sounds.letters[].tongue`                  | `string` or `string[]`                                                                                                         | The tongues that write them, as tags `tongues` declares; every one where absent                                                                                                      |
-| `sounds.edges`                             | `{ edge, sounds }[]`                                                                                                           | The sounds that may stand at each edge of a word, one entry per edge                                                                                                                 |
-| `sounds.edges[].edge`                      | `openConsonant`, `openCluster`, `closeConsonant`, `closeCluster`, `innerCluster`, `vowelPair`, `glide` or `syllabic`, required | Which edge the sounds stand at                                                                                                                                                       |
-| `sounds.edges[].sounds`                    | `string[]` or `any`, required                                                                                                  | The sounds; `any` for every one, an empty list for none                                                                                                                              |
-| `sounds.clusters`                          | `{ max, groups? }`                                                                                                             | How many consonants may stand together                                                                                                                                               |
-| `sounds.clusters.max`                      | `integer`, required                                                                                                            | The most consonants that stand together inside a word                                                                                                                                |
-| `sounds.clusters.groups`                   | `{ what, clusters, use }[]`                                                                                                    | The clusters that may stand inside a word, in groups; a language stating them states no `innerCluster` edge                                                                          |
-| `sounds.clusters.groups[].what`            | `string`, required                                                                                                             | What the group's clusters are made of, as `a nasal and a fricative`                                                                                                                  |
-| `sounds.clusters.groups[].clusters`        | `string[]`, required                                                                                                           | The clusters, as written; no cluster stands in two groups                                                                                                                            |
-| `sounds.clusters.groups[].use`             | `common` or `sparing`, required                                                                                                | How often the group's clusters stand inside a word                                                                                                                                   |
-| `sounds.stress`                            | `first syllable`, `penultimate or final`, `by weight` or `as marked`                                                           | Where a word's stress falls                                                                                                                                                          |
-| `sounds.finals`                            | `{ final, like }[]`                                                                                                            | The syllable finals, for a language whose syllables are parsed by them                                                                                                               |
-| `sounds.finals[].final`                    | `string`, required                                                                                                             | The final, as `ang`                                                                                                                                                                  |
-| `sounds.finals[].like`                     | `string`, required                                                                                                             | What it sounds like                                                                                                                                                                  |
-| `sounds.syllables`                         | map of syllable rules                                                                                                          | What a syllable and a word may open and close on                                                                                                                                     |
-| `sounds.syllables.onsets`                  | `single`                                                                                                                       | What a syllable opens on: a single consonant                                                                                                                                         |
-| `sounds.syllables.codas`                   | `string[]` or `any`                                                                                                            | The consonants that may close a syllable                                                                                                                                             |
-| `sounds.syllables.finals`                  | `string[]` or `any`                                                                                                            | The consonants that may close a word                                                                                                                                                 |
-| `sounds.syllables.doubled`                 | `string[]`                                                                                                                     | The doubled consonants a word may hold; none where empty                                                                                                                             |
-| `sounds.syllables.vowelPairs`              | `string[]`                                                                                                                     | The vowels that may stand together; none where empty                                                                                                                                 |
-| `sounds.syllables.initialVowel`            | `boolean`                                                                                                                      | Whether a word may open on a vowel                                                                                                                                                   |
-| `sounds.syllables.finalVowel`              | `boolean`                                                                                                                      | Whether a word may close on a vowel; `true` where unstated                                                                                                                           |
-| `sounds.syllables.neverInitial`            | `string[]`                                                                                                                     | The letters that never open a word                                                                                                                                                   |
-| `sounds.syllables.signature`               | `string[]`                                                                                                                     | The letters that mark a word as the language's own                                                                                                                                   |
-| `sounds.syllables.harmony`                 | `{ back, front, neutral?, neutralAs?, partners? }`                                                                             | The vowel harmony a word keeps                                                                                                                                                       |
-| `sounds.syllables.harmony.back`            | `string[]`, required                                                                                                           | The back vowels                                                                                                                                                                      |
-| `sounds.syllables.harmony.front`           | `string[]`, required                                                                                                           | The front vowels                                                                                                                                                                     |
-| `sounds.syllables.harmony.neutral`         | `string[]`                                                                                                                     | The vowels of neither set                                                                                                                                                            |
-| `sounds.syllables.harmony.neutralAs`       | `back` or `front`                                                                                                              | The set a word of neutral vowels alone counts as                                                                                                                                     |
-| `sounds.syllables.harmony.partners`        | map of vowels to front vowels                                                                                                  | The front vowel each vowel turns to in an affix's front form, keyed by the vowel                                                                                                     |
-| `sounds.syllables.harmony.partners.<name>` | `string`                                                                                                                       | One vowel's partner, one of the harmony's `front` vowels; the key is a vowel of the harmony                                                                                          |
-| `sounds.joining`                           | `{ first, second, written, example? }[]`                                                                                       | How two parts are written where the first closes and the second opens on the given sounds                                                                                            |
-| `sounds.joining[].first`                   | `string[]`, required                                                                                                           | The sounds the first part closes on                                                                                                                                                  |
-| `sounds.joining[].second`                  | `string[]`, required                                                                                                           | The sounds the second part opens on                                                                                                                                                  |
-| `sounds.joining[].written`                 | `string`, required                                                                                                             | What is written where they meet, as `â`; a join closing on `+`, as `y+`, keeps both and sets it between                                                                              |
-| `sounds.joining[].example`                 | `string`                                                                                                                       | A word joined so                                                                                                                                                                     |
-| `sounds.joins`                             | `{ meeting, rule, letters?, where? }[]`                                                                                        | What happens where two parts of a word meet, one entry per meeting                                                                                                                   |
-| `sounds.joins[].meeting`                   | `C+C`, `V+C` or `V+V`, required                                                                                                | Which sounds meet: a consonant or a vowel closing the first part, then opening the second                                                                                            |
-| `sounds.joins[].rule`                      | `merge`, `insert`, `drop` or `double`, required                                                                                | What happens: one is written, `letters` are set between, the first is lost, or the consonant is doubled                                                                              |
-| `sounds.joins[].letters`                   | `string[]`                                                                                                                     | The letters `insert` sets between or `double` doubles                                                                                                                                |
-| `sounds.joins[].where`                     | `string`                                                                                                                       | Where it holds, as `between stems`; everywhere where absent                                                                                                                          |
-| `sounds.marks`                             | `{ mark, letters, kind, limit }[]`                                                                                             | The marks the language writes on its letters                                                                                                                                         |
-| `sounds.marks[].mark`                      | `string`, required                                                                                                             | The mark's name, as `acute`                                                                                                                                                          |
-| `sounds.marks[].letters`                   | `string[]`, required                                                                                                           | The letters that carry it                                                                                                                                                            |
-| `sounds.marks[].kind`                      | `stress` or `length`, required                                                                                                 | What it says of its letter                                                                                                                                                           |
-| `sounds.marks[].limit`                     | `one` or `any`, required                                                                                                       | How many a word may carry                                                                                                                                                            |
-| `sounds.skeleton`                          | `{ second, between? }[]`                                                                                                       | The vowel set between a root's second and third consonants                                                                                                                           |
-| `sounds.skeleton[].second`                 | `string[]` or `any`, required                                                                                                  | The second consonants the row holds for; `any` for every other                                                                                                                       |
-| `sounds.skeleton[].between`                | `string`                                                                                                                       | The vowel set between; nothing where absent or empty                                                                                                                                 |
-| `sounds.frames`                            | `{ frame, shape, class, makes, examples? }[]`                                                                                  | The patterns a root is set in                                                                                                                                                        |
-| `sounds.frames[].frame`                    | `string`, required                                                                                                             | The frame's name, which a word's `frame` names                                                                                                                                       |
-| `sounds.frames[].shape`                    | `string`, required                                                                                                             | The pattern, the root's consonants numbered, as `K1aK2K3`                                                                                                                            |
-| `sounds.frames[].class`                    | `string[]`, required                                                                                                           | The classes of word it makes, each a base of the [master word classes](#word-classes)                                                                                                |
-| `sounds.frames[].makes`                    | `string`, required                                                                                                             | What it makes of a root                                                                                                                                                              |
-| `sounds.frames[].examples`                 | map of roots to forms                                                                                                          | The form a root takes in the frame, keyed by the root                                                                                                                                |
-| `sounds.frames[].examples.<name>`          | `string`                                                                                                                       | One root's form, bare                                                                                                                                                                |
-| `sounds.readPast`                          | `{ written, readAs?, what }[]`                                                                                                 | Marks and spellings a word is read through before the sound rules hold it                                                                                                            |
-| `sounds.readPast[].written`                | `string`, required                                                                                                             | The mark or spelling the pages write                                                                                                                                                 |
-| `sounds.readPast[].readAs`                 | `string`                                                                                                                       | What the word is read with in its place; absent where it is read as nothing                                                                                                          |
-| `sounds.readPast[].what`                   | `string`, required                                                                                                             | What the mark or spelling is                                                                                                                                                         |
-| `sounds.mutations`                         | `{ mutation, sound, becomes, example? }[]`                                                                                     | The sounds a word changes where a named mutation holds, one entry per sound                                                                                                          |
-| `sounds.mutations[].mutation`              | `string`, required                                                                                                             | The mutation's name, as `wearing`; its rows share it                                                                                                                                 |
-| `sounds.mutations[].sound`                 | `string`, required                                                                                                             | The sound where the mutation does not hold, as `p`; once per mutation                                                                                                                |
-| `sounds.mutations[].becomes`               | `string`, required                                                                                                             | What it becomes where the mutation holds, as `v`                                                                                                                                     |
-| `sounds.mutations[].example`               | `string`                                                                                                                       | A word that shows it                                                                                                                                                                 |
-| `soundChanges`                             | `{ name, from?, to?, steps }[]`                                                                                                | `language` only: named sets of ordered changes, each making one tongue's words from another's                                                                                        |
-| `soundChanges[].name`                      | `string`, required                                                                                                             | The set's name, which no other set of the note shares                                                                                                                                |
-| `soundChanges[].from`                      | `Address`                                                                                                                      | The language note whose words the steps start from                                                                                                                                   |
-| `soundChanges[].to`                        | `Address`                                                                                                                      | The language note whose words the steps make                                                                                                                                         |
-| `soundChanges[].takes`                     | `string`                                                                                                                       | The form of the older word the steps start from, as `accusative`; its citation form where absent                                                                                     |
-| `soundChanges[].steps`                     | `{ step, change, where? }[]`, required                                                                                         | The steps, in the order they apply                                                                                                                                                   |
-| `soundChanges[].steps[].step`              | `string`, required                                                                                                             | The step's label, as `A1` or `"1"`; no label stands twice in a set                                                                                                                   |
-| `soundChanges[].steps[].change`            | `string`, required                                                                                                             | The change in arrow notation, as `` `ph` > `f`; `kh` > `h` ``, or the operation it names in words                                                                                    |
-| `soundChanges[].steps[].where`             | `string`                                                                                                                       | Where it holds, as `word end`; everywhere where absent                                                                                                                               |
-| `elements`                                 | `{ form, variants?, position?, kind?, sense, examples?, word?, joining? }[]`                                                   | `language` only: the elements its names are built from                                                                                                                               |
-| `elements[].form`                          | `string`, required                                                                                                             | The element, as `arn-`                                                                                                                                                               |
-| `elements[].variants`                      | `string[]`                                                                                                                     | The element's other forms, as `aldr-` beside `ald-`                                                                                                                                  |
-| `elements[].position`                      | `opening`, `closing`, `either` or `link`                                                                                       | Where in a name it stands                                                                                                                                                            |
-| `elements[].kind`                          | `byname`, `given` or `place`                                                                                                   | The kind of name it builds, in a language that keeps one set of elements per kind; every kind where absent                                                                           |
-| `elements[].sense`                         | `string`, required                                                                                                             | What it means                                                                                                                                                                        |
-| `elements[].examples`                      | `string[]`                                                                                                                     | The names it is read from                                                                                                                                                            |
-| `elements[].word`                          | `string`                                                                                                                       | The word it is the stem of, a form of `words` of the language or an ancestor                                                                                                         |
-| `elements[].joining`                       | `string`                                                                                                                       | The element's joining form, as `-borgar`, when it qualifies another word                                                                                                             |
-| `roots`                                    | `{ root, sense, field? }[]`                                                                                                    | `language` only: the consonantal roots its words are set from                                                                                                                        |
-| `roots[].root`                             | `string`, required                                                                                                             | The root, as `d-l-k`                                                                                                                                                                 |
-| `roots[].sense`                            | `string`, required                                                                                                             | What it means                                                                                                                                                                        |
-| `roots[].field`                            | `string`                                                                                                                       | The field it belongs to, as `stone`                                                                                                                                                  |
-| `cognates`                                 | `{ forms, proto?, gloss }[]`                                                                                                   | `language` only: sets of forms one older word takes in several languages, stated on the eldest                                                                                       |
-| `cognates[].forms`                         | map of language Addresses to forms, required                                                                                   | The form the set takes in each language, keyed by the language note                                                                                                                  |
-| `cognates[].forms.<name>`                  | `string`                                                                                                                       | One language's form, bare                                                                                                                                                            |
-| `cognates[].gloss`                         | `string`, required                                                                                                             | What the forms mean                                                                                                                                                                  |
-| `cognates[].proto`                         | `string`                                                                                                                       | The reconstructed form the set descends from, in no attested language; printed with an asterisk                                                                                      |
-| `callingNames`                             | `{ closings, minSyllables }`                                                                                                   | `language` only: the short name a long given name is called by                                                                                                                       |
-| `callingNames.closings`                    | `{ form?, doubled?, usual }[]`, required                                                                                       | What a calling name closes on                                                                                                                                                        |
-| `callingNames.closings[].form`             | `string`                                                                                                                       | The ending, as `-u`; a row states `form` or `doubled`, never both                                                                                                                    |
-| `callingNames.closings[].doubled`          | `boolean`                                                                                                                      | The calling name doubles the first syllable instead of taking an ending                                                                                                              |
-| `callingNames.closings[].usual`            | `man`, `woman` or `either`, required                                                                                           | Whose name it usually makes                                                                                                                                                          |
-| `callingNames.minSyllables`                | `integer`, required                                                                                                            | The fewest syllables a given name has that the pages give a calling name                                                                                                             |
-| `older`                                    | `{ form, gloss?, layer? }[]`                                                                                                   | `language` only: the words and names older than its rules, which no sound or name rule holds                                                                                         |
-| `older[].form`                             | `string`, required                                                                                                             | The form as the setting writes it; no form stands twice                                                                                                                              |
-| `older[].gloss`                            | `string`                                                                                                                       | What it means                                                                                                                                                                        |
-| `older[].layer`                            | `string`                                                                                                                       | The historical layer it belongs to, as `Primordial`                                                                                                                                  |
-| `negation`                                 | `{ particle, mutation? }`                                                                                                      | `language` only: how a verb is negated                                                                                                                                               |
-| `negation.particle`                        | `string`, required                                                                                                             | The particle that stands before the verb, a form of `words` of the language or an ancestor                                                                                           |
-| `negation.mutation`                        | `string`                                                                                                                       | The mutation the negated verb takes, named in `sounds.mutations`                                                                                                                     |
-| `naming`                                   | `{ shapes?, edges?, draws?, heldFrom?, nearName? }`                                                                            | `language` only: the shapes, edges and sources its names keep beyond its words' rules                                                                                                |
-| `naming.shapes`                            | `{ of, syllables?, perVowel? }[]`                                                                                              | How long each class of name runs                                                                                                                                                     |
-| `naming.shapes[].of`                       | `name`, `given`, `clan`, `bound` or `compound`, required                                                                       | The class of name; once per class                                                                                                                                                    |
-| `naming.shapes[].syllables`                | `{ min, max }`                                                                                                                 | How many syllables a name of the class runs to                                                                                                                                       |
-| `naming.shapes[].syllables.min`            | `integer`, required                                                                                                            | The fewest                                                                                                                                                                           |
-| `naming.shapes[].syllables.max`            | `integer`, required                                                                                                            | The most; never below `min`                                                                                                                                                          |
-| `naming.shapes[].perVowel`                 | `{ min, max }`                                                                                                                 | How many consonants a name of the class carries to each vowel; a shape states this, `syllables`, or both                                                                             |
-| `naming.shapes[].perVowel.min`             | `number`, required                                                                                                             | The fewest                                                                                                                                                                           |
-| `naming.shapes[].perVowel.max`             | `number`, required                                                                                                             | The most; never below `min`                                                                                                                                                          |
-| `naming.edges`                             | `{ edge, sounds, vowel?, of? }[]`                                                                                              | The sounds a name may open and close on, where names keep edges ordinary words do not                                                                                                |
-| `naming.edges[].edge`                      | an `edge` of `sounds.edges`, required                                                                                          | Which edge of a name the sounds stand at; once per class of name                                                                                                                     |
-| `naming.edges[].sounds`                    | `string[]` or `any`, required                                                                                                  | The sounds; `any` for every one, an empty list for none                                                                                                                              |
-| `naming.edges[].vowel`                     | `boolean`                                                                                                                      | Whether a vowel may stand at the edge too; `false` where unstated                                                                                                                    |
-| `naming.edges[].of`                        | `name`, `given`, `clan`, `bound` or `compound`                                                                                 | The class of name the edge holds for; `name`, every name, where absent                                                                                                               |
-| `naming.draws`                             | `{ kind, elements }[]`                                                                                                         | The element kinds each kind of name is built from                                                                                                                                    |
-| `naming.draws[].kind`                      | `byname`, `given` or `place`, required                                                                                         | The kind of name; once per kind                                                                                                                                                      |
-| `naming.draws[].elements`                  | list of `byname`, `given` or `place`, required                                                                                 | The element kinds, as `elements[].kind` states them                                                                                                                                  |
-| `naming.heldFrom`                          | `{ source, takes, clip?, joining?, elements? }[]`                                                                              | What a place name takes first, by what the place is held from                                                                                                                        |
-| `naming.heldFrom[].source`                 | `string`, required                                                                                                             | What the place is held from, as `a founder`                                                                                                                                          |
-| `naming.heldFrom[].takes`                  | `stem`, `godName`, `givenName` or `element`, required                                                                          | What stands first: a name-stem in any grade, a god's name, a founder's given name, or one of `elements`                                                                              |
-| `naming.heldFrom[].clip`                   | `first`                                                                                                                        | How the name is clipped: to its first element; whole where absent. A name row only                                                                                                   |
-| `naming.heldFrom[].joining`                | `string[]`                                                                                                                     | The joining endings, one of which stands at the seam after the name. A name row only                                                                                                 |
-| `naming.heldFrom[].elements`               | `string[]`                                                                                                                     | The elements that may stand first; required on, and only on, a row that takes an `element`                                                                                           |
-| `naming.nearName`                          | `{ minSyllables, examples? }`                                                                                                  | The near name a long given name carries                                                                                                                                              |
-| `naming.nearName.minSyllables`             | `integer`, required                                                                                                            | The fewest syllables a given name has that carries a near name                                                                                                                       |
-| `naming.nearName.examples`                 | `{ near, given }[]`                                                                                                            | Worked near names                                                                                                                                                                    |
-| `naming.nearName.examples[].near`          | `string`, required                                                                                                             | The near name                                                                                                                                                                        |
-| `naming.nearName.examples[].given`         | `string`, required                                                                                                             | The given name it is the near name of                                                                                                                                                |
+| `data` property                            | Values                                                                                                                         | Description                                                                                                                                                                                    |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `templatePriority`                         | `number`                                                                                                                       | Template priority, _null_ = not a template                                                                                                                                                     |
+| `masteryLevel`                             | `number`                                                                                                                       | HM3 mastery level                                                                                                                                                                              |
+| `parentSkill`                              | `Address`                                                                                                                      | Parent skill this skill specializes                                                                                                                                                            |
+| `names`                                    | `{ pattern, given, <name>... }`                                                                                                | `language` only: how its speakers are named, for `package-build npc new` — see [name lists](#name-lists)                                                                                       |
+| `names.pattern`                            | `string`, `string[]` or map of `gender` words to either, required                                                              | Placeholders such as `{given}`, `{given.male}` and `{clan}`, each naming a list, with literal text around them; a list states several forms, a map each gender's forms                         |
+| `names.given`                              | map of `gender` words to lists of names, required                                                                              | Given names by gender; `female` and `male` are required                                                                                                                                        |
+| `names.given.<name>`                       | `string[]`                                                                                                                     | The given names of one gender                                                                                                                                                                  |
+| `names.<name>`                             | `string[]`                                                                                                                     | A list the placeholder of the same name draws from                                                                                                                                             |
+| `family`                                   | `Address`                                                                                                                      | `language` only: the parent language, naming a skill note with `subType: language`; this language reads the parent's words as its own — see [a language's words](#a-languages-words)           |
+| `abbreviation`                             | `string`                                                                                                                       | `language` only: the tag a dictionary prints for it, as `Prov.`; its full name where unstated — see [dictionaries and glossaries](#dictionaries-and-glossaries)                                |
+| `core`                                     | `boolean`                                                                                                                      | `language` only: `true` where the language must cover the [core vocabulary](#the-core-vocabulary)                                                                                              |
+| `grammar`                                  | `{ plural?, verbs?, agreement?, participles? }`                                                                                | Optional noun plurals, one verb pattern, agreement and participles; supplied shapes only are checked                                                                                           |
+| `grammar.plural`                           | `{ ending, becomes }[]`                                                                                                        | Literal suffix replacements in authored order; the first match wins                                                                                                                            |
+| `grammar.plural[].ending`                  | `string`, required, may be empty                                                                                               | Bare suffix to replace; empty matches every noun                                                                                                                                               |
+| `grammar.plural[].becomes`                 | `string`, required, may be empty                                                                                               | Bare replacement; empty deletes the matching suffix                                                                                                                                            |
+| `grammar.verbs`                            | `{ invariant: true }` or `{ persons: { I, you, heShe, we, youAll, they }, replaces? }`                                         | One regular present pattern, printed once at the dictionary head                                                                                                                               |
+| `grammar.verbs.invariant`                  | `true`                                                                                                                         | Verbs do not change; excludes `persons`                                                                                                                                                        |
+| `grammar.verbs.persons`                    | a map of all six ending strings                                                                                                | Each ending is added to the citation form, or replaces its closing `replaces`; excludes `invariant`                                                                                            |
+| `grammar.verbs.persons.I`                  | `string`, required, may be empty                                                                                               | Ending for I                                                                                                                                                                                   |
+| `grammar.verbs.persons.you`                | `string`, required, may be empty                                                                                               | Ending for you                                                                                                                                                                                 |
+| `grammar.verbs.persons.heShe`              | `string`, required, may be empty                                                                                               | Ending for he/she                                                                                                                                                                              |
+| `grammar.verbs.persons.we`                 | `string`, required, may be empty                                                                                               | Ending for we                                                                                                                                                                                  |
+| `grammar.verbs.persons.youAll`             | `string`, required, may be empty                                                                                               | Ending for you all                                                                                                                                                                             |
+| `grammar.verbs.persons.they`               | `string`, required, may be empty                                                                                               | Ending for they                                                                                                                                                                                |
+| `grammar.verbs.replaces`                   | `string`, nonempty                                                                                                             | Closing letters each ending takes the place of; a citation form closing otherwise takes the ending whole. With `persons` only                                                                  |
+| `grammar.agreement`                        | `{ classes, endings }`                                                                                                         | Adjectives, pronouns or any other named classes agree by swapping among `endings`; see [optional noun and verb forms](#optional-noun-and-verb-forms)                                           |
+| `grammar.agreement.classes`                | `string[]`, required, at least one                                                                                             | Word class bases from the [master word classes](#word-classes), each once                                                                                                                      |
+| `grammar.agreement.endings`                | `string[]`, required, at least two                                                                                             | The singular endings, one per gender; the `plural` rule gives each one's plural                                                                                                                |
+| `grammar.participles`                      | `{ root, affixes }`                                                                                                            | Participle suffixes on the verb root; see [optional noun and verb forms](#optional-noun-and-verb-forms)                                                                                        |
+| `grammar.participles.root`                 | `string[]`, required, at least one, nonempty                                                                                   | Infinitive endings a citation form drops to give the root; the longest that fits wins                                                                                                          |
+| `grammar.participles.affixes`              | `string[]`, required, at least one                                                                                             | Suffixes of `affixes`, by `form`, each attaching to the root as its `replaces` says                                                                                                            |
+| `classModifiers`                           | `string[]`                                                                                                                     | `language` only: the word class modifiers the language uses, each from the [master word classes](#word-classes); empty when unstated                                                           |
+| `fields`                                   | `{ name, holds }[]`                                                                                                            | `language` only: the fields its words are grouped under                                                                                                                                        |
+| `fields[].name`                            | `string`, required                                                                                                             | The field's name, which a word's `field` names                                                                                                                                                 |
+| `fields[].holds`                           | `string`, required                                                                                                             | What the field holds                                                                                                                                                                           |
+| `words`                                    | `{ form, class, field, gloss, … }[]`                                                                                           | `language` only: its words in authored order; its automatic dictionary sorts them alphabetically — see [a language's words](#a-languages-words)                                                |
+| `words[].form`                             | `string`, required                                                                                                             | The word as cited, bare: no backticks                                                                                                                                                          |
+| `words[].variants`                         | `string[]`                                                                                                                     | Its other forms, as a short form beside a long one; a marked use of one cites the word, and a mapped run accepts it                                                                            |
+| `words[].name_sort`                        | `string`                                                                                                                       | Its sort key; the form when unstated                                                                                                                                                           |
+| `words[].class`                            | `string`, required                                                                                                             | A class from the master word classes, base first: `n I f`                                                                                                                                      |
+| `words[].plural`                           | `string`                                                                                                                       | Optional explicit noun plural; the dictionary uses it before the language rule                                                                                                                 |
+| `words[].field`                            | `string`, required                                                                                                             | One of the note's `fields` names                                                                                                                                                               |
+| `words[].gloss`                            | `string` or `string[]`, required                                                                                               | The meaning, in brief; a list states one sense per entry, which a dictionary numbers                                                                                                           |
+| `words[].concept`                          | `string` or `string[]`                                                                                                         | The core concepts the word serves, each an `id` of a [`data.concepts`](#the-core-vocabulary) list; one id, or a list for a word that serves several                                            |
+| `words[].source`                           | `{ kind, language?, form? }`                                                                                                   | Where the word comes from                                                                                                                                                                      |
+| `words[].source.kind`                      | `inherited`, `borrowed`, `kept`, `worn`, `coined`, `substrate` or `island`, required                                           | How the word came into the language                                                                                                                                                            |
+| `words[].source.language`                  | `Address`                                                                                                                      | The language a `borrowed` word came from, naming a skill note with `subType: language`; required for `borrowed`                                                                                |
+| `words[].source.form`                      | `string`                                                                                                                       | The form the word had in its source, bare                                                                                                                                                      |
+| `words[].built`                            | `string[]`                                                                                                                     | The pieces the word is built from, in order, as the note's words and affixes write them; absent for a root word                                                                                |
+| `words[].note`                             | `string`                                                                                                                       | What a source says of the word beyond its pieces, as a cognate it is read with                                                                                                                 |
+| `words[].pronunciation`                    | `string`                                                                                                                       | A respelling, as `sol-MEH-reh`: letters, apostrophes and hyphens, at most one syllable in capitals                                                                                             |
+| `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, named in `sounds.frames` of the language or an ancestor                                                                                                            |
+| `words[].native`                           | `{ map, font?, text }[]`                                                                                                       | The word's native form under a map, stated only where the rows spell it differently — see [a map reads the dictionary first](#a-map-reads-the-dictionary-first)                                |
+| `words[].native[].map`                     | `string`                                                                                                                       | Required: the `data.map.name` the form is written for                                                                                                                                          |
+| `words[].native[].font`                    | `string`                                                                                                                       | The one face the form is for, one the map lists; unstated, every face it lists                                                                                                                 |
+| `words[].native[].text`                    | `string`                                                                                                                       | Required: the word as the script writes it                                                                                                                                                     |
+| `affixes`                                  | `{ form?, zero?, kind?, given?, where?, gloss, attaches?, examples?, barredAfter?, tones? }[]`                                 | `language` only: the affixes a word's `built` pieces may name; each states a `form` or `zero: true`                                                                                            |
+| `affixes[].form`                           | `string`                                                                                                                       | The affix as a `built` piece names it, as `-rith`; absent on a zero affix                                                                                                                      |
+| `affixes[].zero`                           | `boolean`                                                                                                                      | The affix is written as nothing, as a case with no ending; it states no `form`, prints as `∅`, and no `built` piece names it                                                                   |
+| `affixes[].kind`                           | `case`, `derivation`, `tense`, `aspect`, `mood`, `voice`, `name` or `lineage`                                                  | What it makes: a case, a derived word, a verb's tense, aspect, mood or voice, a given name's ending or a lineage name's ending                                                                 |
+| `affixes[].given`                          | `man`, `woman` or `either`                                                                                                     | Who a given name closing on it belongs to; only on an affix of kind `name`                                                                                                                     |
+| `affixes[].where`                          | `string`                                                                                                                       | Where this form stands, for an affix written two ways, as `before a stop`; everywhere where absent                                                                                             |
+| `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[].barredAfter`                    | `string[]`                                                                                                                     | The sounds a stem may not close on to take the affix, as `[n]`                                                                                                                                 |
+| `affixes[].tones`                          | `string`                                                                                                                       | The tone pattern it carries, as `L`                                                                                                                                                            |
+| `affixes[].replaces`                       | `string`                                                                                                                       | What it takes the place of at the close of the stem: `vowel` for any closing vowel, or the letters, as `a`; added to the whole stem where absent                                               |
+| `affixes[].attachesTo`                     | `string[]`                                                                                                                     | The word classes it attaches to, by their base, as `[n, adj]`; every class where absent                                                                                                        |
+| `affixes[].lengthens`                      | `boolean`                                                                                                                      | Whether the stem's last vowel lengthens before it; `false` where unstated, and never beside `replaces`                                                                                         |
+| `affixes[].front`                          | `string`                                                                                                                       | Its form after front vowels, where the language keeps vowel harmony, as `-ür`                                                                                                                  |
+| `tongues`                                  | `{ tag, meaning, language? }[]`                                                                                                | `language` only: the tags a register row's `tongue` names — see [a language's register, sounds and history](#a-languages-register-sounds-and-history)                                          |
+| `tongues[].tag`                            | `string`, required                                                                                                             | Lowercase letters and digits, as `dunhari`, or a tag closing on `:<tongue>`, as `exonym:<tongue>`, which declares `exonym:vylari` and every tag like it                                        |
+| `tongues[].meaning`                        | `string`, required                                                                                                             | What a name of this tongue is                                                                                                                                                                  |
+| `tongues[].language`                       | `Address`                                                                                                                      | The language note the tag names, where it is one                                                                                                                                               |
+| `register`                                 | `{ name, tongue?, kind?, built?, why? }[]`                                                                                     | `language` only: every name the setting gives in the language's reach; the notes carrying each are derived                                                                                     |
+| `register[].name`                          | `string`, required                                                                                                             | The name, as the setting writes it                                                                                                                                                             |
+| `register[].tongue`                        | `string`                                                                                                                       | A tag `tongues` declares, or `translation`; a row states a `tongue`, a `kind`, or both                                                                                                         |
+| `register[].kind`                          | `byname`, `given` or `place`                                                                                                   | What kind of name it is, in a language that sorts its names by kind                                                                                                                            |
+| `register[].built`                         | `string[]`                                                                                                                     | The pieces the name is built from, as a word's `built` writes them                                                                                                                             |
+| `register[].gloss`                         | `string`                                                                                                                       | What the name means, where the pages give its sense                                                                                                                                            |
+| `register[].why`                           | `string`                                                                                                                       | Why the name stands outside the pattern the language's names are built by                                                                                                                      |
+| `retired`                                  | `{ form, instead?, why }[]`                                                                                                    | `language` only: the forms the setting does not write                                                                                                                                          |
+| `retired[].form`                           | `string`, required                                                                                                             | The form the setting does not write                                                                                                                                                            |
+| `retired[].instead`                        | `string` or `string[]`                                                                                                         | What is written in its place; absent where nothing is                                                                                                                                          |
+| `retired[].why`                            | `string`, required                                                                                                             | Why the setting does not write it                                                                                                                                                              |
+| `scope`                                    | `{ folders?, cultures?, lore?, parents?, addresses?, paths?, types?, skip? }`                                                  | `language` only: the notes the register covers                                                                                                                                                 |
+| `scope.folders`                            | `Address[]`                                                                                                                    | Every note whose `packFolder` is one of these folders                                                                                                                                          |
+| `scope.cultures`                           | `Address[]`                                                                                                                    | Every note whose `culture` is one of these cultures                                                                                                                                            |
+| `scope.lore`                               | `Address[]`                                                                                                                    | Every note whose `lore` names one of these notes                                                                                                                                               |
+| `scope.parents`                            | `Address[]`                                                                                                                    | Every note whose `parents` names one of these notes                                                                                                                                            |
+| `scope.addresses`                          | `Address[]`                                                                                                                    | These notes themselves                                                                                                                                                                         |
+| `scope.paths`                              | `string[]`                                                                                                                     | Every note whose file sits below one of these content paths, as `Regions/Aelwyth/`                                                                                                             |
+| `scope.types`                              | `string[]`                                                                                                                     | The note types covered; a note of another type is out of scope whatever else catches it                                                                                                        |
+| `scope.skip`                               | `Address[]`                                                                                                                    | Notes out of scope whatever else catches them                                                                                                                                                  |
+| `sounds`                                   | `{ letters?, edges?, clusters?, stress?, finals?, syllables?, joining?, joins?, marks?, skeleton?, frames?, readPast? }`       | `language` only: the letters it writes and the rules its words keep                                                                                                                            |
+| `sounds.letters`                           | `{ letters, kind, like?, place?, tongue? }[]`                                                                                  | The letters and the sounds they stand for                                                                                                                                                      |
+| `sounds.letters[].letters`                 | `string[]`, required                                                                                                           | The letters or digraphs the row describes                                                                                                                                                      |
+| `sounds.letters[].kind`                    | `string`, required                                                                                                             | What kind of sound they write, as `consonant` or `long vowel`                                                                                                                                  |
+| `sounds.letters[].like`                    | `string`                                                                                                                       | What they sound like; absent where the row states only their kind and place                                                                                                                    |
+| `sounds.letters[].place`                   | `string`                                                                                                                       | Where in the mouth they are made, as `lips` or `tongue-tip`                                                                                                                                    |
+| `sounds.letters[].tongue`                  | `string` or `string[]`                                                                                                         | The tongues that write them, as tags `tongues` declares; every one where absent                                                                                                                |
+| `sounds.edges`                             | `{ edge, sounds }[]`                                                                                                           | The sounds that may stand at each edge of a word, one entry per edge                                                                                                                           |
+| `sounds.edges[].edge`                      | `openConsonant`, `openCluster`, `closeConsonant`, `closeCluster`, `innerCluster`, `vowelPair`, `glide` or `syllabic`, required | Which edge the sounds stand at                                                                                                                                                                 |
+| `sounds.edges[].sounds`                    | `string[]` or `any`, required                                                                                                  | The sounds; `any` for every one, an empty list for none                                                                                                                                        |
+| `sounds.clusters`                          | `{ max, groups? }`                                                                                                             | How many consonants may stand together                                                                                                                                                         |
+| `sounds.clusters.max`                      | `integer`, required                                                                                                            | The most consonants that stand together inside a word                                                                                                                                          |
+| `sounds.clusters.groups`                   | `{ what, clusters, use }[]`                                                                                                    | The clusters that may stand inside a word, in groups; a language stating them states no `innerCluster` edge                                                                                    |
+| `sounds.clusters.groups[].what`            | `string`, required                                                                                                             | What the group's clusters are made of, as `a nasal and a fricative`                                                                                                                            |
+| `sounds.clusters.groups[].clusters`        | `string[]`, required                                                                                                           | The clusters, as written; no cluster stands in two groups                                                                                                                                      |
+| `sounds.clusters.groups[].use`             | `common` or `sparing`, required                                                                                                | How often the group's clusters stand inside a word                                                                                                                                             |
+| `sounds.stress`                            | `{ two, longer, mark? }`                                                                                                       | Where a word's stress falls, as a rule a program reads                                                                                                                                         |
+| `sounds.stress.two`                        | `first` or `last`, required                                                                                                    | The stressed syllable of a word of two syllables                                                                                                                                               |
+| `sounds.stress.longer`                     | `antepenultimate`, `penultimate` or `final`, required                                                                          | The stressed syllable of a word of three or more, counted from its end                                                                                                                         |
+| `sounds.stress.mark`                       | `acute`, `grave` or `circumflex`                                                                                               | The diacritic that marks a stress the rule would not choose; it moves the stress to the syllable it sits on                                                                                    |
+| `sounds.finals`                            | `{ final, like }[]`                                                                                                            | The syllable finals, for a language whose syllables are parsed by them                                                                                                                         |
+| `sounds.finals[].final`                    | `string`, required                                                                                                             | The final, as `ang`                                                                                                                                                                            |
+| `sounds.finals[].like`                     | `string`, required                                                                                                             | What it sounds like                                                                                                                                                                            |
+| `sounds.syllables`                         | map of syllable rules                                                                                                          | What a syllable and a word may open and close on                                                                                                                                               |
+| `sounds.syllables.onsets`                  | `single`                                                                                                                       | What a syllable opens on: a single consonant                                                                                                                                                   |
+| `sounds.syllables.codas`                   | `string[]` or `any`                                                                                                            | The consonants that may close a syllable                                                                                                                                                       |
+| `sounds.syllables.finals`                  | `string[]` or `any`                                                                                                            | The consonants that may close a word                                                                                                                                                           |
+| `sounds.syllables.doubled`                 | `string[]`                                                                                                                     | The doubled consonants a word may hold; none where empty                                                                                                                                       |
+| `sounds.syllables.vowelPairs`              | `string[]`                                                                                                                     | The vowels that may stand together; none where empty                                                                                                                                           |
+| `sounds.syllables.initialVowel`            | `boolean`                                                                                                                      | Whether a word may open on a vowel                                                                                                                                                             |
+| `sounds.syllables.finalVowel`              | `boolean`                                                                                                                      | Whether a word may close on a vowel; `true` where unstated                                                                                                                                     |
+| `sounds.syllables.neverInitial`            | `string[]`                                                                                                                     | The letters that never open a word                                                                                                                                                             |
+| `sounds.syllables.signature`               | `string[]`                                                                                                                     | The letters that mark a word as the language's own                                                                                                                                             |
+| `sounds.syllables.harmony`                 | `{ back, front, neutral?, neutralAs?, partners? }`                                                                             | The vowel harmony a word keeps                                                                                                                                                                 |
+| `sounds.syllables.harmony.back`            | `string[]`, required                                                                                                           | The back vowels                                                                                                                                                                                |
+| `sounds.syllables.harmony.front`           | `string[]`, required                                                                                                           | The front vowels                                                                                                                                                                               |
+| `sounds.syllables.harmony.neutral`         | `string[]`                                                                                                                     | The vowels of neither set                                                                                                                                                                      |
+| `sounds.syllables.harmony.neutralAs`       | `back` or `front`                                                                                                              | The set a word of neutral vowels alone counts as                                                                                                                                               |
+| `sounds.syllables.harmony.partners`        | map of vowels to front vowels                                                                                                  | The front vowel each vowel turns to in an affix's front form, keyed by the vowel                                                                                                               |
+| `sounds.syllables.harmony.partners.<name>` | `string`                                                                                                                       | One vowel's partner, one of the harmony's `front` vowels; the key is a vowel of the harmony                                                                                                    |
+| `sounds.joining`                           | `{ first, second, written, example? }[]`                                                                                       | How two parts are written where the first closes and the second opens on the given sounds                                                                                                      |
+| `sounds.joining[].first`                   | `string[]`, required                                                                                                           | The sounds the first part closes on                                                                                                                                                            |
+| `sounds.joining[].second`                  | `string[]`, required                                                                                                           | The sounds the second part opens on                                                                                                                                                            |
+| `sounds.joining[].written`                 | `string`, required                                                                                                             | What is written where they meet, as `â`; a join closing on `+`, as `y+`, keeps both and sets it between                                                                                        |
+| `sounds.joining[].example`                 | `string`                                                                                                                       | A word joined so                                                                                                                                                                               |
+| `sounds.joins`                             | `{ meeting, rule, letters?, where? }[]`                                                                                        | What happens where two parts of a word meet, one entry per meeting                                                                                                                             |
+| `sounds.joins[].meeting`                   | `C+C`, `V+C` or `V+V`, required                                                                                                | Which sounds meet: a consonant or a vowel closing the first part, then opening the second                                                                                                      |
+| `sounds.joins[].rule`                      | `merge`, `insert`, `drop` or `double`, required                                                                                | What happens: one is written, `letters` are set between, the first is lost, or the consonant is doubled                                                                                        |
+| `sounds.joins[].letters`                   | `string[]`                                                                                                                     | The letters `insert` sets between or `double` doubles                                                                                                                                          |
+| `sounds.joins[].where`                     | `string`                                                                                                                       | Where it holds, as `between stems`; everywhere where absent                                                                                                                                    |
+| `sounds.marks`                             | `{ mark, letters, kind, limit }[]`                                                                                             | The marks the language writes on its letters                                                                                                                                                   |
+| `sounds.marks[].mark`                      | `string`, required                                                                                                             | The mark's name, as `acute`                                                                                                                                                                    |
+| `sounds.marks[].letters`                   | `string[]`, required                                                                                                           | The letters that carry it                                                                                                                                                                      |
+| `sounds.marks[].kind`                      | `stress` or `length`, required                                                                                                 | What it says of its letter                                                                                                                                                                     |
+| `sounds.marks[].limit`                     | `one` or `any`, required                                                                                                       | How many a word may carry                                                                                                                                                                      |
+| `sounds.skeleton`                          | `{ second, between? }[]`                                                                                                       | The vowel set between a root's second and third consonants                                                                                                                                     |
+| `sounds.skeleton[].second`                 | `string[]` or `any`, required                                                                                                  | The second consonants the row holds for; `any` for every other                                                                                                                                 |
+| `sounds.skeleton[].between`                | `string`                                                                                                                       | The vowel set between; nothing where absent or empty                                                                                                                                           |
+| `sounds.frames`                            | `{ frame, shape, class, makes, examples? }[]`                                                                                  | The patterns a root is set in                                                                                                                                                                  |
+| `sounds.frames[].frame`                    | `string`, required                                                                                                             | The frame's name, which a word's `frame` names                                                                                                                                                 |
+| `sounds.frames[].shape`                    | `string`, required                                                                                                             | The pattern, the root's consonants numbered, as `K1aK2K3`                                                                                                                                      |
+| `sounds.frames[].class`                    | `string[]`, required                                                                                                           | The classes of word it makes, each a base of the [master word classes](#word-classes)                                                                                                          |
+| `sounds.frames[].makes`                    | `string`, required                                                                                                             | What it makes of a root                                                                                                                                                                        |
+| `sounds.frames[].examples`                 | map of roots to forms                                                                                                          | The form a root takes in the frame, keyed by the root                                                                                                                                          |
+| `sounds.frames[].examples.<name>`          | `string`                                                                                                                       | One root's form, bare                                                                                                                                                                          |
+| `sounds.readPast`                          | `{ written, readAs?, what }[]`                                                                                                 | Marks and spellings a word is read through before the sound rules hold it                                                                                                                      |
+| `sounds.readPast[].written`                | `string`, required                                                                                                             | The mark or spelling the pages write                                                                                                                                                           |
+| `sounds.readPast[].readAs`                 | `string`                                                                                                                       | What the word is read with in its place; absent where it is read as nothing                                                                                                                    |
+| `sounds.readPast[].what`                   | `string`, required                                                                                                             | What the mark or spelling is                                                                                                                                                                   |
+| `sounds.mutations`                         | `{ mutation, sound, becomes, example? }[]`                                                                                     | The sounds a word changes where a named mutation holds, one entry per sound                                                                                                                    |
+| `sounds.mutations[].mutation`              | `string`, required                                                                                                             | The mutation's name, as `wearing`; its rows share it                                                                                                                                           |
+| `sounds.mutations[].sound`                 | `string`, required                                                                                                             | The sound where the mutation does not hold, as `p`; once per mutation                                                                                                                          |
+| `sounds.mutations[].becomes`               | `string`, required                                                                                                             | What it becomes where the mutation holds, as `v`                                                                                                                                               |
+| `sounds.mutations[].example`               | `string`                                                                                                                       | A word that shows it                                                                                                                                                                           |
+| `soundChanges`                             | `{ name, from?, to?, steps }[]`                                                                                                | `language` only: named sets of ordered changes, each making one tongue's words from another's                                                                                                  |
+| `soundChanges[].name`                      | `string`, required                                                                                                             | The set's name, which no other set of the note shares                                                                                                                                          |
+| `soundChanges[].from`                      | `Address`                                                                                                                      | The language note whose words the steps start from                                                                                                                                             |
+| `soundChanges[].to`                        | `Address`                                                                                                                      | The language note whose words the steps make                                                                                                                                                   |
+| `soundChanges[].takes`                     | `string`                                                                                                                       | The form of the older word the steps start from, as `accusative`; its citation form where absent                                                                                               |
+| `soundChanges[].steps`                     | `{ step, change, where? }[]`, required                                                                                         | The steps, in the order they apply                                                                                                                                                             |
+| `soundChanges[].steps[].step`              | `string`, required                                                                                                             | The step's label, as `A1` or `"1"`; no label stands twice in a set                                                                                                                             |
+| `soundChanges[].steps[].change`            | `string`, required                                                                                                             | The change in arrow notation, as `` `ph` > `f`; `kh` > `h` ``, or the operation it names in words                                                                                              |
+| `soundChanges[].steps[].where`             | `string`                                                                                                                       | Where it holds, as `word end`; everywhere where absent                                                                                                                                         |
+| `elements`                                 | `{ form, variants?, position?, kind?, sense, examples?, word?, joining? }[]`                                                   | `language` only: the elements its names are built from                                                                                                                                         |
+| `elements[].form`                          | `string`, required                                                                                                             | The element, as `arn-`                                                                                                                                                                         |
+| `elements[].variants`                      | `string[]`                                                                                                                     | The element's other forms, as `aldr-` beside `ald-`                                                                                                                                            |
+| `elements[].position`                      | `opening`, `closing`, `either` or `link`                                                                                       | Where in a name it stands                                                                                                                                                                      |
+| `elements[].kind`                          | `byname`, `given` or `place`                                                                                                   | The kind of name it builds, in a language that keeps one set of elements per kind; every kind where absent                                                                                     |
+| `elements[].sense`                         | `string`, required                                                                                                             | What it means                                                                                                                                                                                  |
+| `elements[].examples`                      | `string[]`                                                                                                                     | The names it is read from                                                                                                                                                                      |
+| `elements[].word`                          | `string`                                                                                                                       | The word it is the stem of, a form of `words` of the language or an ancestor                                                                                                                   |
+| `elements[].joining`                       | `string`                                                                                                                       | The element's joining form, as `-borgar`, when it qualifies another word                                                                                                                       |
+| `roots`                                    | `{ root, sense, field? }[]`                                                                                                    | `language` only: the consonantal roots its words are set from                                                                                                                                  |
+| `roots[].root`                             | `string`, required                                                                                                             | The root, as `d-l-k`                                                                                                                                                                           |
+| `roots[].sense`                            | `string`, required                                                                                                             | What it means                                                                                                                                                                                  |
+| `roots[].field`                            | `string`                                                                                                                       | The field it belongs to, as `stone`                                                                                                                                                            |
+| `cognates`                                 | `{ forms, proto?, gloss }[]`                                                                                                   | `language` only: sets of forms one older word takes in several languages, stated on the eldest                                                                                                 |
+| `cognates[].forms`                         | map of language Addresses to forms, required                                                                                   | The form the set takes in each language, keyed by the language note                                                                                                                            |
+| `cognates[].forms.<name>`                  | `string`                                                                                                                       | One language's form, bare                                                                                                                                                                      |
+| `cognates[].gloss`                         | `string`, required                                                                                                             | What the forms mean                                                                                                                                                                            |
+| `cognates[].proto`                         | `string`                                                                                                                       | The reconstructed form the set descends from, in no attested language; printed with an asterisk                                                                                                |
+| `callingNames`                             | `{ closings, minSyllables }`                                                                                                   | `language` only: the short name a long given name is called by                                                                                                                                 |
+| `callingNames.closings`                    | `{ form?, doubled?, usual }[]`, required                                                                                       | What a calling name closes on                                                                                                                                                                  |
+| `callingNames.closings[].form`             | `string`                                                                                                                       | The ending, as `-u`; a row states `form` or `doubled`, never both                                                                                                                              |
+| `callingNames.closings[].doubled`          | `boolean`                                                                                                                      | The calling name doubles the first syllable instead of taking an ending                                                                                                                        |
+| `callingNames.closings[].usual`            | `man`, `woman` or `either`, required                                                                                           | Whose name it usually makes                                                                                                                                                                    |
+| `callingNames.minSyllables`                | `integer`, required                                                                                                            | The fewest syllables a given name has that the pages give a calling name                                                                                                                       |
+| `older`                                    | `{ form, gloss?, layer? }[]`                                                                                                   | `language` only: the words and names older than its rules, which no sound or name rule holds                                                                                                   |
+| `older[].form`                             | `string`, required                                                                                                             | The form as the setting writes it; no form stands twice                                                                                                                                        |
+| `older[].gloss`                            | `string`                                                                                                                       | What it means                                                                                                                                                                                  |
+| `older[].layer`                            | `string`                                                                                                                       | The historical layer it belongs to, as `Primordial`                                                                                                                                            |
+| `negation`                                 | `{ particle, mutation? }`                                                                                                      | `language` only: how a verb is negated                                                                                                                                                         |
+| `negation.particle`                        | `string`, required                                                                                                             | The particle that stands before the verb, a form of `words` of the language or an ancestor                                                                                                     |
+| `negation.mutation`                        | `string`                                                                                                                       | The mutation the negated verb takes, named in `sounds.mutations`                                                                                                                               |
+| `naming`                                   | `{ shapes?, edges?, draws?, heldFrom?, nearName? }`                                                                            | `language` only: the shapes, edges and sources its names keep beyond its words' rules                                                                                                          |
+| `naming.shapes`                            | `{ of, syllables?, perVowel? }[]`                                                                                              | How long each class of name runs                                                                                                                                                               |
+| `naming.shapes[].of`                       | `name`, `given`, `clan`, `bound` or `compound`, required                                                                       | The class of name; once per class                                                                                                                                                              |
+| `naming.shapes[].syllables`                | `{ min, max }`                                                                                                                 | How many syllables a name of the class runs to                                                                                                                                                 |
+| `naming.shapes[].syllables.min`            | `integer`, required                                                                                                            | The fewest                                                                                                                                                                                     |
+| `naming.shapes[].syllables.max`            | `integer`, required                                                                                                            | The most; never below `min`                                                                                                                                                                    |
+| `naming.shapes[].perVowel`                 | `{ min, max }`                                                                                                                 | How many consonants a name of the class carries to each vowel; a shape states this, `syllables`, or both                                                                                       |
+| `naming.shapes[].perVowel.min`             | `number`, required                                                                                                             | The fewest                                                                                                                                                                                     |
+| `naming.shapes[].perVowel.max`             | `number`, required                                                                                                             | The most; never below `min`                                                                                                                                                                    |
+| `naming.edges`                             | `{ edge, sounds, vowel?, of? }[]`                                                                                              | The sounds a name may open and close on, where names keep edges ordinary words do not                                                                                                          |
+| `naming.edges[].edge`                      | an `edge` of `sounds.edges`, required                                                                                          | Which edge of a name the sounds stand at; once per class of name                                                                                                                               |
+| `naming.edges[].sounds`                    | `string[]` or `any`, required                                                                                                  | The sounds; `any` for every one, an empty list for none                                                                                                                                        |
+| `naming.edges[].vowel`                     | `boolean`                                                                                                                      | Whether a vowel may stand at the edge too; `false` where unstated                                                                                                                              |
+| `naming.edges[].of`                        | `name`, `given`, `clan`, `bound` or `compound`                                                                                 | The class of name the edge holds for; `name`, every name, where absent                                                                                                                         |
+| `naming.draws`                             | `{ kind, elements }[]`                                                                                                         | The element kinds each kind of name is built from                                                                                                                                              |
+| `naming.draws[].kind`                      | `byname`, `given` or `place`, required                                                                                         | The kind of name; once per kind                                                                                                                                                                |
+| `naming.draws[].elements`                  | list of `byname`, `given` or `place`, required                                                                                 | The element kinds, as `elements[].kind` states them                                                                                                                                            |
+| `naming.heldFrom`                          | `{ source, takes, clip?, joining?, elements? }[]`                                                                              | What a place name takes first, by what the place is held from                                                                                                                                  |
+| `naming.heldFrom[].source`                 | `string`, required                                                                                                             | What the place is held from, as `a founder`                                                                                                                                                    |
+| `naming.heldFrom[].takes`                  | `stem`, `godName`, `givenName` or `element`, required                                                                          | What stands first: a name-stem in any grade, a god's name, a founder's given name, or one of `elements`                                                                                        |
+| `naming.heldFrom[].clip`                   | `first`                                                                                                                        | How the name is clipped: to its first element; whole where absent. A name row only                                                                                                             |
+| `naming.heldFrom[].joining`                | `string[]`                                                                                                                     | The joining endings, one of which stands at the seam after the name. A name row only                                                                                                           |
+| `naming.heldFrom[].elements`               | `string[]`                                                                                                                     | The elements that may stand first; required on, and only on, a row that takes an `element`                                                                                                     |
+| `naming.nearName`                          | `{ minSyllables, examples? }`                                                                                                  | The near name a long given name carries                                                                                                                                                        |
+| `naming.nearName.minSyllables`             | `integer`, required                                                                                                            | The fewest syllables a given name has that carries a near name                                                                                                                                 |
+| `naming.nearName.examples`                 | `{ near, given }[]`                                                                                                            | Worked near names                                                                                                                                                                              |
+| `naming.nearName.examples[].near`          | `string`, required                                                                                                             | The near name                                                                                                                                                                                  |
+| `naming.nearName.examples[].given`         | `string`, required                                                                                                             | The given name it is the near name of                                                                                                                                                          |
+| `grammar.native`                           | `{ ending, map, font?, text }[]`                                                                                               | Under a logographic map, the signs a derived form takes after its stem's writing — see [a logographic map](#a-logographic-map)                                                                 |
+| `grammar.native[].ending`                  | `plural`, `I`, `you`, `heShe`, `we`, `youAll` or `they`, required                                                              | The ending written; a person only where `verbs.persons` is stated                                                                                                                              |
+| `grammar.native[].map`                     | `string`, required                                                                                                             | The `data.map.name` of a logographic map                                                                                                                                                       |
+| `grammar.native[].font`                    | `string`                                                                                                                       | The one face the writing is for, one the map lists; unstated, every face it lists                                                                                                              |
+| `grammar.native[].text`                    | `string`, required, may be empty                                                                                               | The ending's signs; empty writes the stem alone                                                                                                                                                |
+| `affixes[].native`                         | `{ map, font?, text }[]`                                                                                                       | The affix's writing under a logographic map, for a `built` piece naming it                                                                                                                     |
+| `affixes[].native[].map`                   | `string`, required                                                                                                             | The `data.map.name` of a logographic map                                                                                                                                                       |
+| `affixes[].native[].font`                  | `string`                                                                                                                       | The one face the writing is for, one the map lists; unstated, every face it lists                                                                                                              |
+| `affixes[].native[].text`                  | `string`, required                                                                                                             | The affix as the script writes it                                                                                                                                                              |
+| `emphasis`                                 | `words`, `rubric` or `overline`                                                                                                | `language` only: how the language marks a stressed word, over its script's; `words` makes `*…*` and `**…**` in its runs an error — see [script notes and emphasis](#script-notes-and-emphasis) |
+| `script`                                   | `{ fonts, emphasis, strongEmphasis? }`                                                                                         | `script` only: the faces the script is written in and how it marks emphasis — see [script notes and emphasis](#script-notes-and-emphasis)                                                      |
+| `script.fonts`                             | `string[]`, required                                                                                                           | Installed faces by the slug `font=` names them by; a face belongs to one script                                                                                                                |
+| `script.emphasis`                          | `rubric` or `overline`, required                                                                                               | Sets `*…*` and `**…**` in a run in one of its faces                                                                                                                                            |
+| `script.strongEmphasis`                    | `rubric` or `overline`                                                                                                         | Sets `**…**` instead of `emphasis`                                                                                                                                                             |
 
 #### A language's words
 
@@ -6391,6 +6610,51 @@ ORDER BY position
 ```
 ````
 
+#### The core vocabulary
+
+A setting can state the concepts every one of its languages has a word for, and
+measure each language against them from data. Three keys carry it:
+
+| Key                    | On              | Meaning                                                                                |
+| ---------------------- | --------------- | -------------------------------------------------------------------------------------- |
+| `data.concepts`        | a `doc` note    | The concept list: `{ id, gloss, group }` entries, in the order the report lists them   |
+| `data.core`            | a language note | `true` where the language must cover the list; the report lists these languages        |
+| `data.words[].concept` | a word          | The id of the concept the word serves, or a list of ids for a word that serves several |
+
+```yaml
+---
+shortcode: coreconcepts
+name: { full: Core concepts }
+type: doc
+subType: reference
+data:
+  concepts:
+    - { id: see-verb, gloss: to see, group: senses }
+    - { id: smell-noun, gloss: "a smell; a scent", group: senses }
+    - { id: knee, gloss: the knee, group: body }
+---
+```
+
+The lint holds each to what it means, each finding located at the key at fault:
+
+- a concept's `id` is lowercase letters, digits and `-`, stated once in its list
+  and by one note of the package;
+- a concept's `gloss` and `group` are not blank;
+- `data.core` is stated on a language note only;
+- a word's `concept` names entries of a concept list, each once. An id no list
+  declares is an error at the id, with the nearest declared id offered when one
+  is near: `` `smel-noun` is not a core concept; did you mean `smell-noun`? ``.
+  Where no note states `data.concepts`, every id is unknown, and the message
+  says so.
+
+A language reads the words of its `data.family` chain as its own, so a parent's
+tagged word covers the daughter's concept. `data.core` is not inherited: each
+language that must cover the list states it.
+
+`package-build core` is the report. A concept no word serves is never a lint
+finding; the report lists it so the language can be filled in. See
+[`package-build core`](../commands.md#package-build-core).
+
 #### A language's register, sounds and history
 
 A language note states in frontmatter every fact a check reads about its
@@ -6431,7 +6695,7 @@ data:
       - { edge: closeCluster, sounds: [nd, rd] }
       - { edge: vowelPair, sounds: [ai, au, ei] }
     clusters: { max: 2 }
-    stress: penultimate or final
+    stress: { two: first, longer: penultimate, mark: acute }
     syllables:
       onsets: single
       codas: [b, d, k, sh]
@@ -6580,8 +6844,14 @@ rules hold it, each with what it is read as, or nothing.
 The rest of `sounds` states what a language's own rules read, each from a
 closed list where its values are words:
 
-- `stress`: `first syllable`, `penultimate or final`, `by weight` or
-  `as marked`.
+- `stress`: the rule a program reads, `{ two, longer, mark? }`. `two` is the
+  stressed syllable of a word of two syllables, `first` or `last`; `longer` is
+  the stressed syllable of a word of three or more, counted from its end,
+  `antepenultimate`, `penultimate` or `final`; `mark` is the diacritic, `acute`,
+  `grave` or `circumflex`, that marks a stress the rule would not choose and
+  moves it to the syllable it sits on. Syllables are vowel groups, a pair listed
+  in `syllables.vowelPairs` counting as one. A verse fence's `scan=` counts
+  beats by this rule; see [metres](#metres).
 - `finals`: the syllable finals, each with what it sounds like, for a language
   whose syllables are parsed by them.
 - `syllables`: what a syllable opens on (`single`, a single consonant), the
@@ -6692,44 +6962,44 @@ that keeps vowel harmony gives an affix's form after front vowels in `front`.
 
 Each finding is located at the key at fault:
 
-| Finding                                                                                                                                                                                                                                                                                                                                                                  | Severity |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
-| Any of these keys on a skill of another subType, at the key                                                                                                                                                                                                                                                                                                              | error    |
-| An unknown, missing or wrongly shaped key in an entry                                                                                                                                                                                                                                                                                                                    | error    |
-| A value outside its closed list — an `edge`, an element `position` or `kind`, a register `kind`, `stress`, a join's `meeting` or `rule`, a mark's `kind` or `limit`, `onsets`, `neutralAs`, a closing's `usual`, a cluster group's `use`, an affix's `kind` or `given`, a naming class `of`, a draw's `kind` or `elements`, a held-from `takes` or `clip` — at the value | error    |
-| A `sounds` word other than `any`, at the value                                                                                                                                                                                                                                                                                                                           | error    |
-| A tongue tag that is not lowercase letters and digits, at the tag                                                                                                                                                                                                                                                                                                        | error    |
-| A tongue tag stated twice, at the second                                                                                                                                                                                                                                                                                                                                 | error    |
-| A register or letter tongue `tongues` does not declare, at the tag                                                                                                                                                                                                                                                                                                       | error    |
-| An edge stated twice, at the second                                                                                                                                                                                                                                                                                                                                      | error    |
-| A sound stated twice in one mutation, at the second                                                                                                                                                                                                                                                                                                                      | error    |
-| A cluster stated in two groups, at the second                                                                                                                                                                                                                                                                                                                            | error    |
-| An `innerCluster` edge beside `clusters.groups`, at the edge                                                                                                                                                                                                                                                                                                             | error    |
-| A vowel partner keyed by no vowel of the harmony, at the key, or naming no `front` vowel, at the value                                                                                                                                                                                                                                                                   | error    |
-| A form stated twice in `older`, at the second                                                                                                                                                                                                                                                                                                                            | error    |
-| A negation `mutation` that `sounds.mutations` does not name, at the value                                                                                                                                                                                                                                                                                                | error    |
-| A negation `particle` or an element `word` that is no word of the language or an ancestor, at the value                                                                                                                                                                                                                                                                  | error    |
-| An affix's `given` where its `kind` is not `name`, at the key                                                                                                                                                                                                                                                                                                            | error    |
-| An affix with `zero: true` beside a `form`, at `zero`, or with neither, at the entry                                                                                                                                                                                                                                                                                     | error    |
-| A naming shape stated twice for one class of name, at the second                                                                                                                                                                                                                                                                                                         | error    |
-| A naming shape with neither `syllables` nor `perVowel`, at the entry                                                                                                                                                                                                                                                                                                     | error    |
-| A naming range whose `min` is above its `max`, at the range                                                                                                                                                                                                                                                                                                              | error    |
-| A naming edge stated twice for one class of name, at the second                                                                                                                                                                                                                                                                                                          | error    |
-| A kind of name whose draws are stated twice, at the second                                                                                                                                                                                                                                                                                                               | error    |
-| A held-from row that takes an `element` and names no `elements`, at the row                                                                                                                                                                                                                                                                                              | error    |
-| `elements` on a held-from row that takes no element, or `clip` or `joining` on one that takes no name, at the key                                                                                                                                                                                                                                                        | error    |
-| A `scope` Address that does not resolve, or a type that is no note type                                                                                                                                                                                                                                                                                                  | error    |
-| A tongue `language` or a cognate form's language that is no language note                                                                                                                                                                                                                                                                                                | error    |
-| A register row with neither a `tongue` nor a `kind`, at the row                                                                                                                                                                                                                                                                                                          | error    |
-| A register row tagged `other:<tongue>` or `exonym:<tongue>` whose tongue no `data.tongues` entry links to one language note, at the tongue                                                                                                                                                                                                                               | error    |
-| A register row tagged `other:<tongue>` or `exonym:<tongue>` whose name the tongue's own register does not list under that tongue, at the name                                                                                                                                                                                                                            | error    |
-| A sound-change set's name stated twice, at the second                                                                                                                                                                                                                                                                                                                    | error    |
-| A step label stated twice in one set, at the second                                                                                                                                                                                                                                                                                                                      | error    |
-| A set's `from` or `to` that is no language note, at the value                                                                                                                                                                                                                                                                                                            | error    |
-| A frame class that is no word class base, at the class                                                                                                                                                                                                                                                                                                                   | error    |
-| An affix's `attachesTo` that names no class, at the key, or a class that is no word class base or one named twice, at the class                                                                                                                                                                                                                                          | error    |
-| An affix stating both `replaces` and `lengthens: true`, at `lengthens`                                                                                                                                                                                                                                                                                                   | error    |
-| A calling-name closing with both or neither of `form` and `doubled`                                                                                                                                                                                                                                                                                                      | error    |
+| Finding                                                                                                                                                                                                                                                                                                                                                                                                   | Severity |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| Any of these keys on a skill of another subType, at the key                                                                                                                                                                                                                                                                                                                                               | error    |
+| An unknown, missing or wrongly shaped key in an entry                                                                                                                                                                                                                                                                                                                                                     | error    |
+| A value outside its closed list — an `edge`, an element `position` or `kind`, a register `kind`, a stress rule's `two`, `longer` or `mark`, a join's `meeting` or `rule`, a mark's `kind` or `limit`, `onsets`, `neutralAs`, a closing's `usual`, a cluster group's `use`, an affix's `kind` or `given`, a naming class `of`, a draw's `kind` or `elements`, a held-from `takes` or `clip` — at the value | error    |
+| A `sounds` word other than `any`, at the value                                                                                                                                                                                                                                                                                                                                                            | error    |
+| A tongue tag that is not lowercase letters and digits, at the tag                                                                                                                                                                                                                                                                                                                                         | error    |
+| A tongue tag stated twice, at the second                                                                                                                                                                                                                                                                                                                                                                  | error    |
+| A register or letter tongue `tongues` does not declare, at the tag                                                                                                                                                                                                                                                                                                                                        | error    |
+| An edge stated twice, at the second                                                                                                                                                                                                                                                                                                                                                                       | error    |
+| A sound stated twice in one mutation, at the second                                                                                                                                                                                                                                                                                                                                                       | error    |
+| A cluster stated in two groups, at the second                                                                                                                                                                                                                                                                                                                                                             | error    |
+| An `innerCluster` edge beside `clusters.groups`, at the edge                                                                                                                                                                                                                                                                                                                                              | error    |
+| A vowel partner keyed by no vowel of the harmony, at the key, or naming no `front` vowel, at the value                                                                                                                                                                                                                                                                                                    | error    |
+| A form stated twice in `older`, at the second                                                                                                                                                                                                                                                                                                                                                             | error    |
+| A negation `mutation` that `sounds.mutations` does not name, at the value                                                                                                                                                                                                                                                                                                                                 | error    |
+| A negation `particle` or an element `word` that is no word of the language or an ancestor, at the value                                                                                                                                                                                                                                                                                                   | error    |
+| An affix's `given` where its `kind` is not `name`, at the key                                                                                                                                                                                                                                                                                                                                             | error    |
+| An affix with `zero: true` beside a `form`, at `zero`, or with neither, at the entry                                                                                                                                                                                                                                                                                                                      | error    |
+| A naming shape stated twice for one class of name, at the second                                                                                                                                                                                                                                                                                                                                          | error    |
+| A naming shape with neither `syllables` nor `perVowel`, at the entry                                                                                                                                                                                                                                                                                                                                      | error    |
+| A naming range whose `min` is above its `max`, at the range                                                                                                                                                                                                                                                                                                                                               | error    |
+| A naming edge stated twice for one class of name, at the second                                                                                                                                                                                                                                                                                                                                           | error    |
+| A kind of name whose draws are stated twice, at the second                                                                                                                                                                                                                                                                                                                                                | error    |
+| A held-from row that takes an `element` and names no `elements`, at the row                                                                                                                                                                                                                                                                                                                               | error    |
+| `elements` on a held-from row that takes no element, or `clip` or `joining` on one that takes no name, at the key                                                                                                                                                                                                                                                                                         | error    |
+| A `scope` Address that does not resolve, or a type that is no note type                                                                                                                                                                                                                                                                                                                                   | error    |
+| A tongue `language` or a cognate form's language that is no language note                                                                                                                                                                                                                                                                                                                                 | error    |
+| A register row with neither a `tongue` nor a `kind`, at the row                                                                                                                                                                                                                                                                                                                                           | error    |
+| A register row tagged `other:<tongue>` or `exonym:<tongue>` whose tongue no `data.tongues` entry links to one language note, at the tongue                                                                                                                                                                                                                                                                | error    |
+| A register row tagged `other:<tongue>` or `exonym:<tongue>` whose name the tongue's own register does not list under that tongue, at the name                                                                                                                                                                                                                                                             | error    |
+| A sound-change set's name stated twice, at the second                                                                                                                                                                                                                                                                                                                                                     | error    |
+| A step label stated twice in one set, at the second                                                                                                                                                                                                                                                                                                                                                       | error    |
+| A set's `from` or `to` that is no language note, at the value                                                                                                                                                                                                                                                                                                                                             | error    |
+| A frame class that is no word class base, at the class                                                                                                                                                                                                                                                                                                                                                    | error    |
+| An affix's `attachesTo` that names no class, at the key, or a class that is no word class base or one named twice, at the class                                                                                                                                                                                                                                                                           | error    |
+| An affix stating both `replaces` and `lengthens: true`, at `lengthens`                                                                                                                                                                                                                                                                                                                                    | error    |
+| A calling-name closing with both or neither of `form` and `doubled`                                                                                                                                                                                                                                                                                                                                       | error    |
 
 A fence sets each table back from its relation:
 
@@ -7918,25 +8188,37 @@ Content prepared to be played — a situation with its cast, places, and possibl
 - howto: A task with an outcome, written as the steps that reach it.
 - concept: An explanation of how something works and why it is shaped that way, read to understand rather than to follow.
 - settingguide: A culture's guide to the setting, which names its culture in `data.culture`. It orients a reader to a setting or region, bringing its places, peoples, institutions, and daily life into one usable frame with links to detailed notes.
-
-| `data` property             | Values                                               | Description                                                                                                           |
-| --------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `culture`                   | `Address`                                            | `settingguide` only, and required there: the culture the guide introduces, naming a lore note with `subType: culture` |
-| `map`                       | `{ name, vowels?, fonts, rows }`                     | A mapping, which text marked `map=` with its `name` is rewritten by; any subType. See [mapping notes](#mapping-notes) |
-| `map.name`                  | string                                               | Required: what `map=` names it by, lowercase letters, digits and `-`, unique in the index                             |
-| `map.vowels`                | string                                               | The characters `before: vowel` reads as vowels                                                                        |
-| `map.rows`                  | list of `[from, to]` or `{ from, to, before?, at? }` | Required: the rewrites, in authored order                                                                             |
-| `map.rows[].from`           | string of one or more characters                     | Required in a map row: the characters it matches                                                                      |
-| `map.rows[].to`             | string, which may be empty                           | Required in a map row: what it writes in their place                                                                  |
-| `map.rows[].before`         | `vowel \| consonant`                                 | What must follow the match                                                                                            |
-| `map.rows[].at`             | `start \| end`                                       | Where the match must sit                                                                                              |
-| `map.fonts`                 | list of `{ font, rows? }`                            | Required, at least one: the faces the map is drawn in                                                                 |
-| `map.fonts[].font`          | an installed face's slug                             | Required: the face, as `font=` names it; not `mono`, `serif` or `sans`                                                |
-| `map.fonts[].rows`          | list of `[from, to]` or `{ from, to, before?, at? }` | Rows for this face alone, tried before the shared `rows`                                                              |
-| `map.fonts[].rows[].from`   | string of one or more characters                     | Required in a map row: the characters it matches                                                                      |
-| `map.fonts[].rows[].to`     | string, which may be empty                           | Required in a map row: what it writes in their place                                                                  |
-| `map.fonts[].rows[].before` | `vowel \| consonant`                                 | What must follow the match                                                                                            |
-| `map.fonts[].rows[].at`     | `start \| end`                                       | Where the match must sit                                                                                              |
+- post: A blog post, which states the day it was published in `data.date` and may name its writer in `data.author`. A site whose `site.feed` names a section lists its posts there, newest first, and feeds them as Atom.
+
+| `data` property             | Values                                               | Description                                                                                                               |
+| --------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `culture`                   | `Address`                                            | `settingguide` only, and required there: the culture the guide introduces, naming a lore note with `subType: culture`     |
+| `concepts`                  | list of `{ id, gloss, group }`                       | A core vocabulary's concept list, any subType. See [the core vocabulary](#the-core-vocabulary)                            |
+| `date`                      | `YYYY-MM-DD`                                         | `post` only, and required there: the day the post was published                                                           |
+| `author`                    | string                                               | `post` only: who wrote the post; a post naming none carries the site's byline, the first entry of `authors`               |
+| `concepts[].id`             | string                                               | Required: lowercase letters, digits and `-`, unique in the package                                                        |
+| `concepts[].gloss`          | string                                               | Required: what the concept means, in brief                                                                                |
+| `concepts[].group`          | string                                               | Required: the group the report lists the concept under                                                                    |
+| `map`                       | `{ name, vowels?, fonts, rows }`                     | A mapping, which text marked `map=` with its `name` is rewritten by; any subType. See [mapping notes](#mapping-notes)     |
+| `map.name`                  | string                                               | Required: what `map=` names it by, lowercase letters, digits and `-`, unique in the index                                 |
+| `map.vowels`                | string                                               | The characters `before: vowel` reads as vowels                                                                            |
+| `map.rows`                  | list of `[from, to]` or `{ from, to, before?, at? }` | Required: the rewrites, in authored order                                                                                 |
+| `map.rows[].from`           | string of one or more characters                     | Required in a map row: the characters it matches                                                                          |
+| `map.rows[].to`             | string, which may be empty                           | Required in a map row: what it writes in their place                                                                      |
+| `map.rows[].before`         | `vowel \| consonant`                                 | What must follow the match                                                                                                |
+| `map.rows[].at`             | `start \| end`                                       | Where the match must sit                                                                                                  |
+| `map.fonts`                 | list of `{ font, rows? }`                            | Required, at least one: the faces the map is drawn in                                                                     |
+| `map.fonts[].font`          | an installed face's slug                             | Required: the face, as `font=` names it; not `mono`, `serif` or `sans`                                                    |
+| `map.fonts[].rows`          | list of `[from, to]` or `{ from, to, before?, at? }` | Rows for this face alone, tried before the shared `rows`                                                                  |
+| `map.fonts[].rows[].from`   | string of one or more characters                     | Required in a map row: the characters it matches                                                                          |
+| `map.fonts[].rows[].to`     | string, which may be empty                           | Required in a map row: what it writes in their place                                                                      |
+| `map.fonts[].rows[].before` | `vowel \| consonant`                                 | What must follow the match                                                                                                |
+| `map.fonts[].rows[].at`     | `start \| end`                                       | Where the match must sit                                                                                                  |
+| `metres`                    | `{ name, beats, kind }[]`                            | The metres a verse fence's `scan=` names; any subType. See [metres](#metres)                                              |
+| `metres[].name`             | string                                               | Required: what `scan=` names it by, lowercase letters, digits and `-`, unique in the package                              |
+| `metres[].beats`            | `integer`, required                                  | The beats of one line, above zero                                                                                         |
+| `metres[].kind`             | `accentual`                                          | Required: how the beats are counted                                                                                       |
+| `map.logographic`           | `true`                                               | The script writes meanings: a run's words are written by the lexicon alone, and the rows write only the text between them |
 
 A setting guide introduces one culture's view of the setting, so it names that
 culture, and a `doc` of any other `subType` has no culture of its own to name.
@@ -7988,8 +8270,7 @@ site is its homepage and its pages, and nothing is generated between them.
 
 There is no landing page and no section. A section appears in **no address**: a
 page publishes at `/<package>/<type>-<shortcode>/`, which names no directory. A
-section is what Hugo calls a content directory, and the note format does not
-carry one.
+section is a content directory, and the note format does not carry one.
 
 So a `doc`'s `subType` is a **genre** and nothing else, closed to the values
 above.