@heroiclands/package-build 23.12.8 → 24.0.0

package/docs/reference/note-types.md

@@ -463,11 +463,12 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.names`            | a language's name lists                                                                                                                      | How this language's speakers are named, for `package-build npc new`: `pattern` builds a name from placeholders such as "{given} {clan}" and literal text, `given` maps a gender to a list of given names, `female` and `male` required, and every other key is a list of names a placeholder of the same name draws from. A language skill note only. See [name lists](format-details.md#name-lists). |
 | `data.family`           | an Address                                                                                                                                   | The parent language, as a language skill note: this language reads the parent's words, and its parents' in turn, as its own. A language skill note only. See [a language's words](format-details.md#a-languages-words).                                                                                                                                                                               |
 | `data.abbreviation`     | a string, such as `Prov.`                                                                                                                    | The tag a dictionary prints for the language, beside an entry's class and in an etymology, as `Prov.`; the language's full name where unstated. A language skill note only. See [a language's words](format-details.md#a-languages-words).                                                                                                                                                            |
+| `data.core`             | `true` or `false`                                                                                                                            | Whether the language must cover the core vocabulary: `true` lists it in the `package-build core` report. A language skill note only. See [the core vocabulary](format-details.md#the-core-vocabulary).                                                                                                                                                                                                |
 | `data.classModifiers`   | list of word class modifiers                                                                                                                 | The class modifiers the language uses, from the master word classes. A word's class may carry only these. Empty when unstated. A language skill note only.                                                                                                                                                                                                                                            |
 | `data.fields`           | list of `{ name, holds }`                                                                                                                    | The fields the language's words are grouped under. A language skill note only.                                                                                                                                                                                                                                                                                                                        |
 | `data.words`            | list of `{ form, class, field, gloss, … }`                                                                                                   | The words this language states, one map each, in authored order; its automatic dictionary sorts them alphabetically. A language skill note only. See [a language's words](format-details.md#a-languages-words).                                                                                                                                                                                       |
 | `data.affixes`          | list of `{ form, gloss, attaches?, examples? }`                                                                                              | The affixes a word's `built` pieces may name, each with its gloss. A language skill note only.                                                                                                                                                                                                                                                                                                        |
-| `data.grammar`          | a map — `{ plural?, verbs? }`                                                                                                                | Optional noun plurals and one verb pattern for dictionary presentation. Only the shape of supplied keys is checked; no word must follow or state a rule. A language skill note only.                                                                                                                                                                                                                  |
+| `data.grammar`          | a map — `{ plural?, verbs?, agreement?, participles?, native? }`                                                                             | Optional noun plurals, one verb pattern, agreement, participles and the endings' logographic writings, for dictionary presentation, the mapped-run word check and logographic maps. Only the shape of supplied keys is checked; no word must follow or state a rule. A language skill note only.                                                                                                      |
 | `data.tongues`          | list of `{ tag, meaning, language? }`                                                                                                        | The tags a register row's `tongue` may name, each with what it means. A language skill note only.                                                                                                                                                                                                                                                                                                     |
 | `data.register`         | list of `{ name, tongue?, kind?, built?, gloss?, why? }`                                                                                     | Every name the setting gives in the language's reach, with its tongue and pieces; the notes carrying each name are derived. A language skill note only.                                                                                                                                                                                                                                               |
 | `data.retired`          | list of `{ form, instead?, why }`                                                                                                            | The forms the setting does not write, and why. A language skill note only.                                                                                                                                                                                                                                                                                                                            |
@@ -481,6 +482,8 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.older`            | list of `{ form, gloss?, layer? }`                                                                                                           | The words and names older than the language's rules, which no sound or name rule holds. A language skill note only.                                                                                                                                                                                                                                                                                   |
 | `data.negation`         | a map — `{ particle, mutation? }`                                                                                                            | How a verb is negated. A language skill note only.                                                                                                                                                                                                                                                                                                                                                    |
 | `data.naming`           | a map — `{ shapes?, edges?, draws?, heldFrom?, nearName? }`                                                                                  | The shapes, edges and sources the language's names keep beyond its words' rules. A language skill note only.                                                                                                                                                                                                                                                                                          |
+| `data.emphasis`         | `words`, `rubric` or `overline`                                                                                                              | How the language marks a stressed word, over its script's `emphasis`: `rubric` or `overline` sets `*…*` and `**…**` so in a run of the language, and `words` marks it with a word, so either is a finding. Only a skill of `subType: language` states it.                                                                                                                                             |
+| `data.script`           | a map — `{ fonts, emphasis, strongEmphasis? }`                                                                                               | A script note's faces and how it marks emphasis. Only a skill of `subType: script` states it.                                                                                                                                                                                                                                                                                                         |
 
 **Inner keys** — a key a field's value does not declare is an error at its own line and column.
 
@@ -491,12 +494,13 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.fields[].name`                      | a string                                                                                                  | yes      | The field's name, which a word's `field` names.                                                                                                                                                                                                                                                                                          |
 | `data.fields[].holds`                     | a string                                                                                                  | yes      | What the field holds.                                                                                                                                                                                                                                                                                                                    |
 | `data.words[].form`                       | the word as cited, bare                                                                                   | yes      | The word as cited, with no backticks.                                                                                                                                                                                                                                                                                                    |
-| `data.words[].variants`                   | a list of forms                                                                                           | no       | The word's other forms, such as a long form beside a short one; a marked use of one cites the word.                                                                                                                                                                                                                                      |
+| `data.words[].variants`                   | a list of forms                                                                                           | no       | The word's other forms, such as a long form beside a short one; a marked use of one cites the word, and a mapped run accepts it and the forms the language's rules derive from it.                                                                                                                                                       |
 | `data.words[].name_sort`                  | a string                                                                                                  | no       | The sort key; the form when unstated.                                                                                                                                                                                                                                                                                                    |
 | `data.words[].class`                      | a word class, base first, such as `n I f`                                                                 | yes      | A class from the master word classes: a base, then the modifiers the language declares in `classModifiers`.                                                                                                                                                                                                                              |
 | `data.words[].plural`                     | a string                                                                                                  | no       | The noun's explicit plural, where it differs from the language's optional plural rule. A dictionary uses this form before the rule; no rule agreement is checked.                                                                                                                                                                        |
 | `data.words[].field`                      | one of the language's `fields` names                                                                      | yes      | The field tag beside the dictionary entry, named in the language's `fields`.                                                                                                                                                                                                                                                             |
 | `data.words[].gloss`                      | a string, or a list of senses                                                                             | yes      | The meaning, in brief; a list states one sense per entry, which a dictionary numbers.                                                                                                                                                                                                                                                    |
+| `data.words[].concept`                    | a core concept's id, or a list of them                                                                    | no       | The core concepts the word serves, each an `id` of a `data.concepts` list. The core report counts the word toward them.                                                                                                                                                                                                                  |
 | `data.words[].source`                     | a map — `{ kind, language?, form? }`                                                                      | no       | Where the word comes from.                                                                                                                                                                                                                                                                                                               |
 | `data.words[].source.kind`                | one of inherited, borrowed, kept, worn, coined, substrate, island                                         | yes      | How the word came into the tongue.                                                                                                                                                                                                                                                                                                       |
 | `data.words[].source.language`            | a language skill Address                                                                                  | no       | The tongue the word was borrowed from; required for `borrowed`.                                                                                                                                                                                                                                                                          |
@@ -507,10 +511,10 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.words[].tones`                      | a string                                                                                                  | no       | A tone pattern, such as `LHL`.                                                                                                                                                                                                                                                                                                           |
 | `data.words[].root`                       | a string                                                                                                  | no       | A consonantal skeleton, such as `d-l-k`.                                                                                                                                                                                                                                                                                                 |
 | `data.words[].frame`                      | a frame of the language's `sounds.frames`                                                                 | no       | The frame a root is set in, named in the language's `sounds.frames`.                                                                                                                                                                                                                                                                     |
-| `data.words[].native`                     | a list of `{ map, font?, text }`                                                                          | no       | The word's native form under a map, stated only where the map's rows spell it differently. Its derived forms are spelled by the rows.                                                                                                                                                                                                    |
+| `data.words[].native`                     | a list of `{ map, font?, text }`                                                                          | no       | The word's native form under a map. Under a map that spells by its rows it is stated only where the rows spell the word differently, and the word's derived forms are spelled by the rows; under a logographic map it is the word's writing, which its derived forms and the words built on it are written from.                         |
 | `data.words[].native[].map`               | a mapping note's `data.map.name`                                                                          | yes      | The map the native form is written for.                                                                                                                                                                                                                                                                                                  |
 | `data.words[].native[].font`              | a face the map lists                                                                                      | no       | The one face the native form is for; unstated, it is for every face the map lists, and a form stated for a face wins over it there.                                                                                                                                                                                                      |
-| `data.words[].native[].text`              | the word in the script, as the map's characters                                                           | yes      | The word as the script writes it, where the map's rows would write it otherwise.                                                                                                                                                                                                                                                         |
+| `data.words[].native[].text`              | the word in the script, as the map's characters                                                           | yes      | The word as the script writes it, where the map's rows would write it otherwise, or as a logographic map writes it.                                                                                                                                                                                                                      |
 | `data.affixes[].form`                     | the affix as written, such as `-rith`                                                                     | no       | The affix as a word's `built` names it; absent on a zero affix.                                                                                                                                                                                                                                                                          |
 | `data.affixes[].zero`                     | `true`                                                                                                    | no       | The affix is written as nothing, such as a case with no ending; it states no `form`, prints as `∅`, and no `built` piece names it.                                                                                                                                                                                                       |
 | `data.affixes[].kind`                     | one of case, derivation, tense, aspect, mood, voice, name, lineage                                        | no       | What the affix makes.                                                                                                                                                                                                                                                                                                                    |
@@ -519,11 +523,16 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.affixes[].gloss`                    | a string                                                                                                  | yes      | What the affix means.                                                                                                                                                                                                                                                                                                                    |
 | `data.affixes[].attaches`                 | a string                                                                                                  | no       | How it attaches, in words, such as `replaces a closing vowel`.                                                                                                                                                                                                                                                                           |
 | `data.affixes[].replaces`                 | `vowel`, or the letters, such as `a`                                                                      | no       | What it takes the place of at the close of the stem: `vowel` for any closing vowel, or the letters it replaces; added to the whole stem where absent.                                                                                                                                                                                    |
+| `data.affixes[].attachesTo`               | a list of word classes, such as `[n, adj]`                                                                | no       | The word classes it attaches to, by their base; every class where absent. A suffix stating `replaces` derives forms of these classes' words alone.                                                                                                                                                                                       |
 | `data.affixes[].lengthens`                | `true` or `false`                                                                                         | no       | Whether the stem's last vowel lengthens before the affix; `false` where unstated. An affix that `replaces` the stem's close does not also lengthen it.                                                                                                                                                                                   |
 | `data.affixes[].front`                    | the affix as written, such as `-ür`                                                                       | no       | Its form after front vowels, where the language keeps vowel harmony.                                                                                                                                                                                                                                                                     |
 | `data.affixes[].examples`                 | a list of strings                                                                                         | no       | The names the affix is read from.                                                                                                                                                                                                                                                                                                        |
 | `data.affixes[].barredAfter`              | a list of sounds                                                                                          | no       | The sounds a stem may not close on to take the affix.                                                                                                                                                                                                                                                                                    |
 | `data.affixes[].tones`                    | a tone pattern, such as `L`                                                                               | no       | The tone pattern the affix carries, written as a word's `tones` is.                                                                                                                                                                                                                                                                      |
+| `data.affixes[].native`                   | a list of `{ map, font?, text }`                                                                          | no       | The affix's writing under a logographic map, which a word whose `built` names the affix is written with.                                                                                                                                                                                                                                 |
+| `data.affixes[].native[].map`             | a mapping note's `data.map.name`                                                                          | yes      | The map the native form is written for.                                                                                                                                                                                                                                                                                                  |
+| `data.affixes[].native[].font`            | a face the map lists                                                                                      | no       | The one face the native form is for; unstated, it is for every face the map lists, and a form stated for a face wins over it there.                                                                                                                                                                                                      |
+| `data.affixes[].native[].text`            | the word in the script, as the map's characters                                                           | yes      | The word as the script writes it, where the map's rows would write it otherwise, or as a logographic map writes it.                                                                                                                                                                                                                      |
 | `data.grammar.plural`                     | list of `{ ending, becomes }`                                                                             | no       | Default noun plurals, replacing the first matching literal ending in authored order. A word's explicit plural wins; no word is checked against this rule.                                                                                                                                                                                |
 | `data.grammar.plural[].ending`            | a literal ending string, which may be empty                                                               | yes      | The bare suffix replaced by this rule; empty matches every noun.                                                                                                                                                                                                                                                                         |
 | `data.grammar.plural[].becomes`           | a literal ending string, which may be empty                                                               | yes      | The bare replacement; empty removes the matching suffix.                                                                                                                                                                                                                                                                                 |
@@ -537,6 +546,17 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.grammar.verbs.persons.youAll`       | an ending string, empty for unchanged                                                                     | yes      | The ending for you all, added to the citation form or in place of its closing `replaces`.                                                                                                                                                                                                                                                |
 | `data.grammar.verbs.persons.they`         | an ending string, empty for unchanged                                                                     | yes      | The ending for they, added to the citation form or in place of its closing `replaces`.                                                                                                                                                                                                                                                   |
 | `data.grammar.verbs.replaces`             | the closing letters every ending takes the place of                                                       | no       | Letters a citation form closes on, swapped for each `persons` ending: with `then`, `lokathen` and `zor` give `lokazor`. A citation form closing otherwise takes the ending whole. With `persons` only.                                                                                                                                   |
+| `data.grammar.agreement`                  | a map — `{ classes, endings }`                                                                            | no       | How words of the named classes agree with a noun: a word closing on one of the `endings` also takes each other one, and each form takes the `plural` rule. Read by the mapped-run word check.                                                                                                                                            |
+| `data.grammar.agreement.classes`          | a list of word class bases, such as `[adj, pron]`                                                         | yes      | The word classes that agree, each a base of the master word classes.                                                                                                                                                                                                                                                                     |
+| `data.grammar.agreement.endings`          | a list of at least two literal endings, such as `[os, a, on]`                                             | yes      | The singular endings an agreeing word swaps among, one for each gender; the `plural` rule gives each one's plural. A word closing on none does not agree.                                                                                                                                                                                |
+| `data.grammar.participles`                | a map — `{ root, affixes }`                                                                               | no       | Participles on the verb root: a verb closing on a `root` ending drops it, and each named suffix attaches to what is left; a participle closing on an `agreement` ending agrees. Read by the mapped-run word check.                                                                                                                       |
+| `data.grammar.participles.root`           | a list of closing letters, such as `[athen, ethen]`                                                       | yes      | The infinitive endings a verb's citation form drops to give its root, the longest that matches first. A verb closing on none has no participle.                                                                                                                                                                                          |
+| `data.grammar.participles.affixes`        | a list of suffixes of `data.affixes`, such as `[-andar, -thos]`                                           | yes      | The participle suffixes, each attaching to the root as its own `replaces` says: `vowel` or letters take the place of the root's close, and none adds it whole.                                                                                                                                                                           |
+| `data.grammar.native`                     | a list of `{ ending, map, font?, text }`                                                                  | no       | Under a logographic map, the signs a noun's plural or a verb's present form is written with after its stem's writing, one entry per ending, map and face.                                                                                                                                                                                |
+| `data.grammar.native[].ending`            | one of plural, I, you, heShe, we, youAll, they                                                            | yes      | The ending written: `plural` for a noun's plural, or a person of `verbs.persons` for a verb's present form.                                                                                                                                                                                                                              |
+| `data.grammar.native[].map`               | a logographic mapping note's `data.map.name`                                                              | yes      | The logographic map the ending is written for.                                                                                                                                                                                                                                                                                           |
+| `data.grammar.native[].font`              | a face the map lists                                                                                      | no       | The one face the writing is for; unstated, it is for every face the map lists, and a writing stated for a face wins over it there.                                                                                                                                                                                                       |
+| `data.grammar.native[].text`              | the ending in the script, as the map's characters; empty writes the stem alone                            | yes      | The signs written after the stem's writing.                                                                                                                                                                                                                                                                                              |
 | `data.tongues[].tag`                      | a tag such as `dunhari`, or `exonym:<tongue>`                                                             | yes      | The tag a register row's `tongue` names: lowercase letters and digits, or a tag closing on `:<tongue>`, which declares one tag per tongue named after the colon.                                                                                                                                                                         |
 | `data.tongues[].meaning`                  | a string                                                                                                  | yes      | What a name of this tongue is.                                                                                                                                                                                                                                                                                                           |
 | `data.tongues[].language`                 | a language skill Address                                                                                  | no       | The language note the tag names, where it is one.                                                                                                                                                                                                                                                                                        |
@@ -572,7 +592,10 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.sounds.clusters.groups[].what`      | a string, such as `a nasal and a fricative`                                                               | yes      | What the clusters of the group are made of.                                                                                                                                                                                                                                                                                              |
 | `data.sounds.clusters.groups[].clusters`  | a list of clusters                                                                                        | yes      | The clusters, as written; a digraph counts as one consonant.                                                                                                                                                                                                                                                                             |
 | `data.sounds.clusters.groups[].use`       | one of common, sparing                                                                                    | yes      | How often the group's clusters stand inside a word.                                                                                                                                                                                                                                                                                      |
-| `data.sounds.stress`                      | one of first syllable, penultimate or final, by weight, as marked                                         | no       | Where a word's stress falls.                                                                                                                                                                                                                                                                                                             |
+| `data.sounds.stress`                      | a map — `{ two, longer, mark? }`                                                                          | no       | Where a word's stress falls, as a rule a program reads.                                                                                                                                                                                                                                                                                  |
+| `data.sounds.stress.two`                  | one of first, last                                                                                        | yes      | The stressed syllable of a word of two syllables.                                                                                                                                                                                                                                                                                        |
+| `data.sounds.stress.longer`               | one of antepenultimate, penultimate, final                                                                | yes      | The stressed syllable of a word of three or more, counted from its end.                                                                                                                                                                                                                                                                  |
+| `data.sounds.stress.mark`                 | one of acute, grave, circumflex                                                                           | no       | The diacritic that marks a stress the rule would not choose; it moves the stress to the syllable it sits on.                                                                                                                                                                                                                             |
 | `data.sounds.finals`                      | list of `{ final, like }`                                                                                 | no       | The syllable finals, for a language whose syllables are parsed by them.                                                                                                                                                                                                                                                                  |
 | `data.sounds.finals[].final`              | a final as written, such as `ang`                                                                         | yes      | The final.                                                                                                                                                                                                                                                                                                                               |
 | `data.sounds.finals[].like`               | a string                                                                                                  | yes      | What it sounds like.                                                                                                                                                                                                                                                                                                                     |
@@ -684,6 +707,9 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.naming.nearName.examples`           | list of `{ near, given }`                                                                                 | no       | Worked near names, each beside its given name.                                                                                                                                                                                                                                                                                           |
 | `data.naming.nearName.examples[].near`    | a near name, such as `Anlâ`                                                                               | yes      | The near name.                                                                                                                                                                                                                                                                                                                           |
 | `data.naming.nearName.examples[].given`   | a given name                                                                                              | yes      | The given name it is the near name of.                                                                                                                                                                                                                                                                                                   |
+| `data.script.fonts`                       | list of installed faces' slugs                                                                            | yes      | The faces the script is written in, by the slug `font=` names them by. A face belongs to one script.                                                                                                                                                                                                                                     |
+| `data.script.emphasis`                    | `rubric` or `overline`                                                                                    | yes      | How the script marks a stressed word: `rubric` sets it in red, `overline` draws a line above it. It sets `*…*` and `**…**` inside a run in one of its faces, unless the run's language states its own `emphasis`.                                                                                                                        |
+| `data.script.strongEmphasis`              | `rubric` or `overline`                                                                                    | no       | The convention `**…**` takes instead of `emphasis`'s.                                                                                                                                                                                                                                                                                    |
 
 **System mappings**
 
@@ -965,18 +991,26 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 
 ### doc
 
-**Subtypes:** `rules`, `userguide`, `reference`, `howto`, `concept`, `settingguide`.
+**Subtypes:** `rules`, `userguide`, `reference`, `howto`, `concept`, `settingguide`, `post`.
 
-| Field          | Shape                                    | Meaning                                                                                                                                     |
-| -------------- | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| `data.culture` | an Address                               | The culture a setting guide introduces, as a culture lore note. Required on `settingguide`; no other subType states it.                     |
-| `data.map`     | a map — `{ name, vowels?, fonts, rows }` | A mapping, which text marked `map=` with its `name` is rewritten by before it is set. See [mapping notes](format-details.md#mapping-notes). |
+| Field           | Shape                                                  | Meaning                                                                                                                                                                    |
+| --------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `data.concepts` | list of `{ id, gloss, group }`                         | The concepts of a core vocabulary, in the order the report lists them. See [the core vocabulary](format-details.md#the-core-vocabulary).                                   |
+| `data.date`     | string                                                 | The day a post was published, as `YYYY-MM-DD`. Required on a `post`; no other subType states it. Posts are listed and fed newest first by it.                              |
+| `data.author`   | string                                                 | Who wrote a post, as the byline prints them. A post that names none carries the site's byline, the first entry of `authors`; no other subType states it.                   |
+| `data.culture`  | an Address                                             | The culture a setting guide introduces, as a culture lore note. Required on `settingguide`; no other subType states it.                                                    |
+| `data.map`      | a map — `{ name, logographic?, vowels?, fonts, rows }` | A mapping, which text marked `map=` with its `name` is rewritten by before it is set. See [mapping notes](format-details.md#mapping-notes).                                |
+| `data.metres`   | list of `{ name, beats, kind }`                        | The metres a verse fence's `scan=` names. A fence that states one is warned at each line that cannot have its beats. See [metres](../authoring/links-and-markup.md#metre). |
 
 **Inner keys** — a key a field's value does not declare is an error at its own line and column.
 
 | Key                              | Shape                                                | Required | Meaning                                                                                                                                                                                                |
 | -------------------------------- | ---------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `data.concepts[].id`             | lowercase letters, digits and `-`                    | yes      | The concept's id, which a word's `concept` names. Unique in the package.                                                                                                                               |
+| `data.concepts[].gloss`          | a short gloss, such as `a smell; a scent`            | yes      | What the concept means, in brief.                                                                                                                                                                      |
+| `data.concepts[].group`          | a group name, such as `senses`                       | yes      | The group the report lists the concept under.                                                                                                                                                          |
 | `data.map.name`                  | string                                               | yes      | What `map=` names the map by: lowercase letters, digits and `-`, unique in the package.                                                                                                                |
+| `data.map.logographic`           | `true`                                               | no       | The script writes meanings: a mapped run's words are written by the language's lexicon alone, and the rows write only the text between them.                                                           |
 | `data.map.vowels`                | string                                               | no       | The characters a row's `before: vowel` reads as vowels; any other letter is a consonant.                                                                                                               |
 | `data.map.rows`                  | list of `[from, to]` or `{ from, to, before?, at? }` | yes      | The rewrites, each `[from, to]` or `{ from, to, before?, at? }`: `before` is `vowel` or `consonant`, `at` is `start` or `end`. The longest `from` wins, and a character no row matches passes through. |
 | `data.map.rows[].from`           | a string of one or more characters                   | yes      | The one or more characters the row matches.                                                                                                                                                            |
@@ -990,6 +1024,9 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 | `data.map.fonts[].rows[].to`     | a string, which may be empty                         | yes      | What the row writes in their place; empty to drop them.                                                                                                                                                |
 | `data.map.fonts[].rows[].before` | string                                               | no       | `vowel` or `consonant`: what must follow the match for the row to apply.                                                                                                                               |
 | `data.map.fonts[].rows[].at`     | string                                               | no       | `start` or `end`: where the match must sit for the row to apply.                                                                                                                                       |
+| `data.metres[].name`             | string                                               | yes      | What a verse fence's `scan=` names the metre by: lowercase letters, digits and `-`, unique in the package.                                                                                             |
+| `data.metres[].beats`            | a whole number above zero                            | yes      | The beats of one line.                                                                                                                                                                                 |
+| `data.metres[].kind`             | one of accentual                                     | yes      | How the beats are counted: `accentual`, one beat for each stressed syllable the language's stress rule and the beat convention give.                                                                   |
 
 ### macro