@heroiclands/package-build 23.12.8 → 24.0.0

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.
 
@@ -1910,7 +1909,15 @@ authored labels supply none.
 
 1. A `.name` span whose whole text matches an indexed `name.full` or
    `name.aliases` should be a link. Use `[[place-arden|Arden Vale]]` or
-   `[[place-arden|]]` to introduce that note.
+   `[[place-arden|]]` to introduce that note. A span with a `data-type`
+   matches only notes of that type, and only notes of that subtype when it
+   names one; an untyped span matches a note of any type. One name can
+   belong to two things, so
+   `[Theinuvael]{.name data-type="affiliation/lineage"}` draws no warning
+   when _Theinuvael_ is an alias of a place note, while
+   `[Theinuvael]{.name data-type="place"}` and `[Theinuvael]{.name}` should
+   be links to it. The same match decides a span's identity for the rules
+   below and for the unwritten-name advisory.
 2. Mark or link each name at most once per note. An indexed full name and its
    declared aliases share one identity, including across different heading
    anchors. Other labels use their whole text as their identity: different
@@ -1921,10 +1928,9 @@ authored labels supply none.
    note under any label. Possessives and regular plurals count as uses; other
    indexed forms can be declared aliases.
 
-Bold is emphasis. A whole bold span exactly matching an indexed full name or
-alias receives one advisory to mark or link the name. It supplies no name
-occurrence or introduction, and bold containing a marked or linked name
-receives no such advisory. Unknown bold phrases supply no names.
+Bold is emphasis and is never read as a name. A bold label such as
+`**Strength**:` is ordinary emphasis even when its text matches an indexed
+full name or alias, and it supplies no name occurrence or introduction.
 
 Inline Markdown remains active inside name spans, and name spans remain
 valid inside emphasis:
@@ -1968,7 +1974,8 @@ This is derived metadata, not frontmatter. Documentation mirrors and assets
 do not duplicate a note's occurrences. The [`names` relation](#content-tables)
 flattens these entries with their containing NOTE Address.
 
-Lint groups names without an indexed full-name or alias match by supplied
+Lint groups names without an indexed full-name or alias match, among notes
+of the span's type and subtype when it supplies them, by supplied
 classification and lists all their source uses. It also groups conflicting
 annotations of the same visible name. Untyped uses do not conflict. A bare
 type and its subtype agree; different supplied types or different supplied
@@ -1978,7 +1985,7 @@ exit status. Supplied-value errors prevent publication and compilation.
 
 #### Text marked with a language, a font or a map
 
-`lang=`, `font=` and `map=` on a span, a generic div or a poetry fence are read
+`lang=`, `font=` and `map=` on a span, a generic div or a verse fence are read
 by the build and never written through as ordinary attributes. Each is
 optional, and a run inside a div or a fence inherits the keys the div or fence
 states, its own keys overriding them. On a named block the three keys are
@@ -2007,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
@@ -2015,7 +2023,7 @@ with a real language's tag alone keeps its Markdown. See
 
 Each own-note metadata record carries `runs` in source order, an empty array
 when the body marks nothing. Every entry has exactly `kind` (`span`, `block` or
-`poetry`), `lang`, `tag`, `font`, `map`, `line` and `column`: `lang`, `font` and
+`verse`), `lang`, `tag`, `font`, `map`, `line` and `column`: `lang`, `font` and
 `map` as written, its own or inherited, `tag` the BCP 47 tag `lang` resolves
 to, each `null` when absent, and the position of the span's `[`, the div's
 `:::` or the fence's opening. Every value is a string or a number and none is a
@@ -2046,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
@@ -2108,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
@@ -2184,10 +2195,13 @@ word's start:
 lists under a `tongue` other than `translation`, or a form one rule derives from a lexicon form —
 the `data.grammar.plural` plural of a noun or its own `plural`, a verb's form
 with one ending of `data.grammar.verbs.persons` (in place of a closing
-`data.grammar.verbs.replaces` where one is stated), or a suffix of `data.affixes`
-stating `replaces` (`vowel` takes the place of a closing `a`, `e`, `i`, `o` or
+`data.grammar.verbs.replaces` where one is stated), a suffix of `data.affixes`
+stating `replaces` on a word of a class its `attachesTo` names, or on any word
+where it names none (`vowel` takes the place of a closing `a`, `e`, `i`, `o` or
 `u`, accented or not; letters take the place of those letters; a stem closing
-otherwise takes the suffix whole). A compound not known whole is checked part by
+otherwise takes the suffix whole), an agreeing form `data.grammar.agreement`
+gives a word of one of its `classes`, or a participle `data.grammar.participles`
+gives a verb (see [optional noun and verb forms](#optional-noun-and-verb-forms)). A compound not known whole is checked part by
 part at its hyphens and en dashes. Any other word is an error at its first
 character, once per run; see
 [a mapped run's words](../authoring/links-and-markup.md#a-mapped-runs-words):
@@ -2219,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
@@ -3314,7 +3525,7 @@ inherited words are read through `language_lineage`.
 **`affixes`** is one row per entry of `data.affixes` on every language note,
 and **`fields`** one per entry of `data.fields`, in the order the note states
 them. Each has `language` and `position` as `words` does, then every key of the
-entry as its own column: `form`, `zero`, `kind`, `given`, `where`, `gloss`, `attaches`, `replaces`, `lengthens`, `front`, `examples`, `barredAfter`
+entry as its own column: `form`, `zero`, `kind`, `given`, `where`, `gloss`, `attaches`, `replaces`, `attachesTo`, `lengthens`, `front`, `examples`, `barredAfter`
 and `tones` for an affix, then `written`, its form as a table prints it (`∅` for a zero affix), `name` and `holds` for a field. A key an entry does not state is
 `NULL`, `examples` is a list, and a language note tagged `gm` contributes no
 row on a public surface. An affix's `tones` is the tone pattern it carries,
@@ -3338,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`                                                                                                                                                                                                                                                                                                                         |
@@ -3398,14 +3609,14 @@ metadata supplies `names` in that package's SQL schema. Public queries exclude
 GM-only owners; all/native contexts retain them. Only authored occurrences
 contribute rows, so generated queries and sections add no further names.
 
-**`runs`** is one row per span, generic div and poetry fence an authored note
+**`runs`** is one row per span, generic div and verse fence an authored note
 body marks with `lang=`, `font=` or `map=`. Each row has these columns,
 including on an empty relation:
 
 | Column   | SQL type  | Meaning                                                                                      |
 | -------- | --------- | -------------------------------------------------------------------------------------------- |
 | `owner`  | `VARCHAR` | Containing authored page's canonical NOTE Address, or `NULL` when the record has no Address. |
-| `kind`   | `VARCHAR` | `span`, `block` or `poetry`.                                                                 |
+| `kind`   | `VARCHAR` | `span`, `block` or `verse`.                                                                  |
 | `lang`   | `VARCHAR` | The language as written, its own or inherited, or `NULL`.                                    |
 | `tag`    | `VARCHAR` | The BCP 47 tag `lang` resolves to, or `NULL` when it resolves to none.                       |
 | `font`   | `VARCHAR` | The font as written, its own or inherited, or `NULL`.                                        |
@@ -3860,11 +4071,11 @@ The caption attaches to exactly the next supported block:
 | Markdown table                       | `table`       | Table          |
 | Image, Markdown or wikilink          | `figure`      | Figure         |
 | SQL fence, including backtick SQL    | `table`       | Table          |
-| Poetry fence                         | `poetry`      | Poem           |
+| Verse fence                          | `verse`       | Poem           |
 | Any other code fence                 | `code`        | Code           |
 | Paragraph, quote block or fenced div | `prose`       | Prose          |
 
-The optional `type` attribute overrides inference and accepts `figure`, `table`, `poetry`, `code`, `prose`, and `example`. `type=example` uses **Example 1**, **Example 2**, and so on. It does not allow an unsupported target. A heading, list, thematic break, another caption or end of document after a caption is an error. Caption markers without separating spaces or caption text are errors too.
+The optional `type` attribute overrides inference and accepts `figure`, `table`, `verse`, `code`, `prose`, and `example`. `type=example` uses **Example 1**, **Example 2**, and so on. It does not allow an unsupported target. A heading, list, thematic break, another caption or end of document after a caption is an error. Caption markers without separating spaces or caption text are errors too.
 
 Identifiers are optional and must be unique within the note. Classes are unrestricted; `.border` uses the shared border style, while other classes can be styled by the medium. On a captioned table or SQL fence, `.full-width` sets the table across the page in a PDF book instead of in one column (`: Regional trade routes {.full-width}`); the other surfaces ignore it. Named attributes use `key=value`, with quoted values for text containing spaces. Use `#id` and `.class` rather than `id=` and `class=`; event-handler attributes are refused.
 
@@ -5870,235 +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? }`                                                                                                          | Optional dictionary noun plurals and one verb pattern; 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                                                        |
-| `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[].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
 
@@ -6209,6 +6446,59 @@ A language uses only its own stated grammar, including for words
 listed from an ancestor; an inherited word retains its explicit plural.
 Grammar is not inherited through `family`.
 
+**Agreement** states which word classes agree with a noun and the singular
+endings they agree by, one for each gender:
+
+```yaml
+grammar:
+  plural:
+    - { ending: os, becomes: oi }
+    - { ending: on, becomes: oi }
+    - { ending: a, becomes: ai }
+  agreement:
+    classes: [adj, pron]
+    endings: [os, a, on]
+```
+
+A word whose class base is one of `classes` and whose form closes on one of
+`endings` (the longest that leaves a stem) also has that ending swapped for
+each other one, and each of those forms, and the word itself, takes the plural
+the `plural` rule gives. So the adjective _alathos_ gives _alatha_ and
+_alathon_, and the plural rule gives _alathoi_ and _alathai_. A word closing on
+no ending, such as _ethlen_, does not agree, and a word of another class, such
+as the noun _marendos_, keeps its own plural alone. `classes` names at least
+one base of the [master word classes](#word-classes), each once, and `endings`
+states at least two endings, each once. Agreement is by these endings alone:
+there are no cases or declensions.
+
+**Participles** attach to the verb root, which is the citation form less its
+infinitive ending:
+
+```yaml
+affixes:
+  - { form: "-andar", gloss: "doing it", replaces: vowel }
+  - { form: "-thos", gloss: "done" }
+grammar:
+  participles:
+    root: [athen, ethen]
+    affixes: ["-andar", "-thos"]
+```
+
+A verb closing on one of `root` (the longest that leaves a root) drops it, and
+each suffix of `data.affixes` that `affixes` names by its `form` attaches to
+what is left as its own `replaces` says, or whole where it states none: the
+`front` form attaches too. So _dokathen_ gives the root _dok-_, which gives
+_dokandar_ and _dokthos_. A participle closing on an agreement ending agrees,
+so _dokthos_ also gives _doktha_, _dokthon_, _dokthoi_ and _dokthai_. A verb
+closing on no `root` ending has no participle. `root` names at least one
+nonempty ending and `affixes` at least one suffix the language's `data.affixes`
+states; an affix it names that is a prefix, or that the language does not
+state, is an error at the entry.
+
+Neither rule is used by the dictionary. Both are read by the
+[mapped-run word check](#mapping-notes), which accepts the forms they give,
+and `package-build lexicon --derived` lists the same forms.
+
 All grammar is optional. Only a supplied key's shape is checked: no language
 must supply a pattern, no noun must supply gender or plural, and no word is
 checked against a rule or required to provide an exception. There are no
@@ -6320,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
@@ -6360,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]
@@ -6459,8 +6794,8 @@ note of the package: `{ tag: vylari, language: skill-vylarilng }` makes
 `exonym:vylari` read the Vylari note. That note's `data.register` must hold a
 row of the same name, case folded and NFC, whose `tongue` is the tongue itself,
 so a misspelt foreign name is caught where it is listed. A tongue that no entry
-links to a language note, or that entries link to two, is a warning at the
-row's `tongue`; a missing name is a warning at its `name`:
+links to a language note, or that entries link to two, is an error at the
+row's `tongue`; a missing name is an error at its `name`:
 
 > `` `Dunharra` is registered as `other:vylari`, but the register of Vylari Language (skill-vylarilng) lists no `vylari` name `Dunharra`; correct the spelling, or register the name there first ``
 
@@ -6509,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
@@ -6610,49 +6951,55 @@ to take the affix.
 
 **An affix states `replaces`** where it takes the place of the stem's close —
 `vowel` for any closing vowel, or the letters, as `a` — and is added to the
-whole stem where it states none. An affix states `lengthens: true` where the
+whole stem where it states none. An affix states `attachesTo` where it
+attaches to some word classes and not others, naming each by its base, as
+`attachesTo: [n, adj]`: a suffix stating `replaces` then derives forms of those
+classes' words alone, so `-andi` with `attachesTo: [n]` gives _zunelandi_ from
+the noun _zunel_ and nothing from a verb. Where it states none, the suffix
+attaches to a word of every class. An affix states `lengthens: true` where the
 stem's last vowel lengthens before it, and never beside `replaces`. A language
 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                                                                                                                                                                                                                               | warning  |
-| 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                                                                                                                                                                                                                            | warning  |
-| 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 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:
 
@@ -7841,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.
@@ -7911,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.