@heroiclands/package-build 24.0.0 → 24.0.2

package/docs/content-format.md

@@ -31,7 +31,9 @@ Leading `:` captions describe the next supported block; `:@` captions also numbe
 
 A code fence with language `verse` keeps verse lines, stanza breaks and relative indentation. Its numbered caption uses the **Poem** label. Generic `:::` divs and `[inline spans]{.class}` accept attributes. See [verse](authoring/links-and-markup.md#verse), [fenced divs](authoring/links-and-markup.md#fenced-divs) and [inline spans](authoring/links-and-markup.md#inline-spans). `numstep=N` numbers every Nth line. `col1=` and `col2=` set the poem in at most two columns, each a `:`-joined stack of `language[/mapping[/font]]` entries, the first in the normal tone and the rest in grey; with columns, each blank-line group of `[text]{lang=…}` spans is one verse line, every entry sets the span in its language, and a `***` line breaks the stanza. See [verse in columns](authoring/links-and-markup.md#verse-in-columns).
 
-A span, a generic div or a verse fence marks its text's language with `lang=`, the font it is set in with `font=` and a mapping with `map=`, each optional, and the runs inside a div or a fence inherit its keys. `lang=` is a name the package declares in `languages` or a BCP 47 tag, and gives the language tag alone. `font=` is a face of the installed `@heroiclands/fonts`, named by its class without `hl-`, or `mono`, `serif` or `sans`. `map=` names a mapping note: a `doc` note whose `data.map` lists the fonts it is drawn in and rows that rewrite the text before it is set, a font's own rows first. With `lang=` naming a language whose configured `note` names its language note, a word whose entry states a `native` form for the map is written by it, and the rows spell every other word. A map stating `logographic: true` spells no word by its rows: each word is written by its own `native` entry or its parts' writings, and a word with neither, or whose form stands for entries written differently, is a located error. Every word of such a run is a lexicon form, a word of a name the language note's own register lists under a tongue other than `translation`, or a form a plural row, the verb pattern or an affix stating `replaces` derives from a lexicon form, and any other word is an error at the word. A character a face does not draw, after the map, is an error at the character it came from. A verse fence that states `scan=` (the `name` of a `data.metres` entry of a `doc` note) with a `lang=` whose language note states `data.sounds.stress` is counted line by line by the beat convention, and a line that cannot have the metre's beats is a warning at the line; see [metres](reference/format-details.md#metres). Text with a font, a map or a declared language is plain, except that text set in a face takes `*…*` and `**…**`: they render by the convention its language note's `data.emphasis` states, else the one the script note listing its face states in `data.script` (`rubric` or `overline`), else plainly, and a language whose `data.emphasis` is `words` makes them an error. Every marked construct is a row of the `runs` relation, every mapping row of the `maps` relation, and every native form of the `natives` relation. See [marking language, font and mapping](authoring/links-and-markup.md#marking-language-font-and-mapping).
+A code fence with language `scroll` sets text in a script whose script note states `direction: vertical-rl` as columns, top to bottom, read from the right. The lines of a paragraph are joined, and each paragraph starts a fresh column. `rows=N` is the characters in a column and `cols=M` the columns in a panel, each a whole number above zero; `lang=`, `font=` and `map=` mark the text as on a verse fence, and a fence naming no `font=` takes the face of a map drawn in one. The site, the preview and Foundry set it with `writing-mode: vertical-rl` in a panel that scrolls sideways from the right; the book draws its panels as images from the face's outlines, each with its roman text as alt text. A scroll fence in a script written in lines is an error. See [scrolls](authoring/links-and-markup.md#scrolls).
+
+A span, a generic div, a verse fence or a scroll fence marks its text's language with `lang=`, the font it is set in with `font=` and a mapping with `map=`, each optional, and the runs inside a div or a fence inherit its keys. `lang=` is a name the package declares in `languages` or a BCP 47 tag, and gives the language tag; where the language note states `data.writtenIn`, the script the language is written in as a `map` and a `font` the map lists, a run marked with the language alone takes that map and face, and a run's own `map=` or `font=` overrides its half of the default. `font=` is a face of the installed `@heroiclands/fonts`, named by its class without `hl-`, or `mono`, `serif` or `sans`. `map=` names a mapping note: a `doc` note whose `data.map` lists the fonts it is drawn in and rows that rewrite the text before it is set, a font's own rows first. With `lang=` naming a language whose configured `note` names its language note, a word whose entry states a `native` form for the map is written by it, and the rows spell every other word. A map stating `logographic: true` spells no word by its rows: each word is written by its own `native` entry or its parts' writings, and a word with neither, or whose form stands for entries written differently, is a located error. Every word of such a run is a lexicon form, a word of a name the language note's own register lists under a tongue other than `translation`, or a form a plural row, the verb pattern or an affix stating `replaces` derives from a lexicon form, and any other word is an error at the word. A character a face does not draw, after the map, is an error at the character it came from. A verse fence that states `scan=` (the `name` of a `data.metres` entry of a `doc` note) with a `lang=` whose language note states `data.sounds.stress` is counted line by line by the beat convention, and a line that cannot have the metre's beats is a warning at the line; see [metres](reference/format-details.md#metres). Text with a font, a map or a declared language is plain, except that text set in a face takes `*…*` and `**…**`: they render by the convention its language note's `data.emphasis` states, else the one the script note listing its face states in `data.script` (`rubric` or `overline`), else plainly, and a language whose `data.emphasis` is `words` makes them an error. Every marked construct is a row of the `runs` relation, every mapping row of the `maps` relation, and every native form of the `natives` relation. See [marking language, font and mapping](authoring/links-and-markup.md#marking-language-font-and-mapping).
 
 Mark a name without a note as `[Name]{.name data-type="being"}`; the optional
 classification uses the declared note vocabulary. The [name-marking
@@ -175,6 +177,6 @@ Places, affiliations, lore and beings may name their culture in `data.culture`,
 
 An affiliation may name the trade, temple or order tongue it keeps in its own `data.language`. An affiliation that reaches no culture is a warning, in a tree holding a culture note. A language needs no culture and no affiliation. See [type: affiliation](reference/format-details.md#type-affiliation).
 
-A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss — one sense or a list of them, which a dictionary numbers — with its source, its variant forms, the pieces it is built from and a note, beside `data.classModifiers`, `data.fields` and `data.affixes`, each affix with the `kind` it makes, for a given name's ending who the name is `given` to, and the stem closes it is barred after; a zero affix states `zero: true` and no form. The notes a word is cited from are derived, not written: a note cites a word by marking it in italics in its prose, matched by form or a variant with diacritics and case set aside. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary entries in `data.glossary`: common words in its core vocabulary, dictionary words with a context meaning, or phrases, compounds and terms of art outside the dictionary with their own gloss. An entry naming a word of its resolved language takes the word's senses and class and links to its language entry; a `definition` supplies the entry's meaning instead. Common marks belong to the glossary's owner. A language note with nonempty `data.words` receives its full Dictionary section automatically: one alphabetical list with field tags and one key. A culture or affiliation with nonempty `data.glossary` receives only its explicitly declared entries in its Glossary section; ranks and offices stand in the affiliation's own sections. A note without the relevant frontmatter receives no such section. All surfaces show these sections after the authored text, or under an existing `{#dictionary}`, `{#lexicon}` or `{#glossary}` heading after its introduction. There are no setting-wide dictionary or glossary pages. Every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `affixes`, `fields`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with its culture associations; a fence sets custom views with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. A `doc` note states a setting's core concepts in `data.concepts`, a language note says it must cover them with `data.core: true`, and a word names the concepts it serves in `concept`; `package-build core` lists what each covering language has no word for (see [the core vocabulary](reference/format-details.md#the-core-vocabulary)). Every fact a check reads about a language's names, sounds and history is frontmatter too: `data.tongues` and `data.register` (every name the setting gives in the language's reach, the notes carrying each derived from the index, and a name tagged `other:<tongue>` or `exonym:<tongue>` one that the tongue's own language note registers under that tongue), `data.retired`, `data.scope`, `data.sounds` (letters with their place, word edges from a closed list, the cluster limit and the groups of clusters inside a word, the stress rule (`two`, `longer` and `mark`), syllable finals, syllable rules and vowel harmony with each vowel's front partner, the joining of parts, written marks, a root's skeleton vowel and frames, the spellings read past, and named mutations such as wearing and voicing), `data.soundChanges` (named sets of ordered steps), `data.elements` (each standing `opening`, `closing`, `either` or `link`, for one kind of name, with the word it is the stem of and its joining form), `data.roots`, `data.cognates` (with a reconstructed `proto` form), `data.callingNames`, `data.older` (the forms older than the rules), `data.negation` (the negative particle and the mutation it brings) and `data.naming` (how long each class of name runs, the edges names keep that words do not, the element kinds each kind of name draws on, what a place name takes from what it is held from, and the near name), each a relation — `sounds` as `letters`, `edges`, `clusters`, `cluster_groups`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past` and `mutations`, `soundChanges` as `sound_changes`, `callingNames` as `calling_names` — that a fence sets back on the page. A word's citations also come from a note whose name, alias or rank or office title spells it whole. See [a language's words](reference/format-details.md#a-languages-words), [a language's register, sounds and history](reference/format-details.md#a-languages-register-sounds-and-history), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
+A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss — one sense or a list of them, which a dictionary numbers — with its source, its variant forms, the pieces it is built from and a note, beside `data.classModifiers`, `data.fields` and `data.affixes`, each affix with the `kind` it makes, for a given name's ending who the name is `given` to, and the stem closes it is barred after; a zero affix states `zero: true` and no form. The notes a word is cited from are derived, not written: a note cites a word by marking it in italics in its prose, matched by form or a variant with diacritics and case set aside. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary entries in `data.glossary`: common words in its core vocabulary, dictionary words with a context meaning, or phrases, compounds and terms of art outside the dictionary with their own gloss. An entry naming a word of its resolved language takes the word's senses and class and links to its language entry; a `definition` supplies the entry's meaning instead. Common marks belong to the glossary's owner. A language note with nonempty `data.words` receives its full Dictionary section automatically: one alphabetical list with field tags and one key. A culture or affiliation with nonempty `data.glossary` receives only its explicitly declared entries in its Glossary section; ranks and offices stand in the affiliation's own sections. A note without the relevant frontmatter receives no such section. All surfaces show these sections after the authored text, or under an existing `{#dictionary}`, `{#lexicon}` or `{#glossary}` heading after its introduction. There are no setting-wide dictionary or glossary pages. Every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `affixes`, `fields`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with its culture associations; a fence sets custom views with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. A `doc` note states a setting's core concepts in `data.concepts`, a language note says it must cover them with `data.core: true`, and a word names the concepts it serves in `concept`; `package-build core` lists what each covering language has no word for (see [the core vocabulary](reference/format-details.md#the-core-vocabulary)). Every fact a check reads about a language's names, sounds and history is frontmatter too: `data.tongues` and `data.register` (every name the setting gives in the language's reach, the notes carrying each derived from the index, and a name tagged `other:<tongue>` or `exonym:<tongue>` one that the tongue's own language note registers under that tongue), `data.retired`, `data.scope`, `data.sounds` (letters with their place, their IPA and the tongues that write them, each a declared tag or a language note's Address, word edges from a closed list, the cluster limit and the groups of clusters inside a word, the stress rule (`two`, `longer`, which may be `first`, and `mark`), syllable finals with their IPA, syllable rules and vowel harmony with each vowel's front partner, the joining of parts, written marks, a root's skeleton vowel and frames, the spellings read past, and named mutations such as wearing and voicing), `data.soundChanges` (named sets of ordered steps), `data.elements` (each standing `opening`, `closing`, `either` or `link`, for one kind of name, with the word it is the stem of and its joining form), `data.roots`, `data.cognates` (with a reconstructed `proto` form), `data.callingNames`, `data.older` (the forms older than the rules), `data.negation` (the negative particle and the mutation it brings) and `data.naming` (how long each class of name runs, the edges names keep that words do not, the element kinds each kind of name draws on, what a place name takes from what it is held from, and the near name), each a relation — `sounds` as `letters`, `edges`, `clusters`, `cluster_groups`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past` and `mutations`, `soundChanges` as `sound_changes`, `callingNames` as `calling_names` — that a fence sets back on the page. A `doc` note may state a spelling guide's `data.sounds.letters` and `data.sounds.marks` alone, its letter rows naming tongues by language note Addresses, and they join the `letters` and `marks` relations under the guide's Address. A word's citations also come from a note whose name, alias or rank or office title spells it whole. See [a language's words](reference/format-details.md#a-languages-words), [a language's register, sounds and history](reference/format-details.md#a-languages-register-sounds-and-history), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
 
 Blockquote alerts use `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, or `[!]`, with optional attributes after the marker. They replace the former info and warn div fences; secret blocks remain supported. See [alerts](authoring/links-and-markup.md#alerts).

package/docs/guides/site.md

@@ -223,6 +223,49 @@ The build writes these keys; [what the theme draws](../reference/theme-pages.md)
 describes the panel each one feeds — the infobox, the hero band, the related
 card, and search — and the generated sections the theme draws as any other.
 
+## Decide which pages a reader finds
+
+Every note is written as a page, linked or not, and a page is served at its
+address. What a reader can find is what the homepage leads to: the sitemap and
+the site search cover the pages reachable from the homepage, directly or
+through the pages it links, and no others.
+
+Reachability is read from the links the rendered pages carry, never from the
+notes' sources. A page is reachable when an authored link leads to it:
+
+- a link in the homepage or in the body of a reachable note, including the
+  links a `pagelist` or a `sql` table writes into the body;
+- a link in the menu or the rest of the site chrome;
+- a link in a listing: the pages of a section page, a tag page, and the posts
+  an Atom feed lists, once a reachable page links the section, the tag or the
+  feed. A tag chip on a reachable page links its tag page when `site.tags` is
+  on, so every page carrying the tag is then reachable.
+
+The links the build generates do not make a page reachable. These are the
+Related card, the previous and next links, the infobox links, and the sections
+generated after a note's text (Within, Governed by, Governed places,
+Chronology, Events, Accounts, What followed, In song and story). Each is drawn
+without a link to a page outside the reachable set, and a section left with
+nothing under it is not drawn. An infobox value that names an unreachable page
+is set as plain text. A link written in prose or produced by a query is kept
+wherever it points, and it is what makes its target reachable.
+
+A page that is not reachable is the way to preview a page in place. Write the
+note, build the site, and read the page at its address on the live site; link
+it from the homepage or from a linked page when it is ready to publish. For a
+note `doc-charlie` in the package `setting`:
+
+1. Add `doc-charlie` to the content tree. It is written at
+   `/setting/doc-charlie/` and appears in neither the sitemap nor the search.
+2. Read it at `/setting/doc-charlie/`.
+3. Link it, for example `[[doc-charlie|Charlie]]` in a linked note, to publish
+   it. The next build lists it in the sitemap and the search.
+
+An address is a short code and the site serves no directory listing, so an
+unlinked page is found only by someone who knows its address. The content
+index that `package-build content-index` writes is a release asset and is not
+part of the site.
+
 ## Show marked text in its font
 
 A site shows text marked with `font=` and one of the faces of

package/docs/guides/writing-in-invented-scripts.md

@@ -142,6 +142,29 @@ address of the language's `skill` note of `subType: language`, whose
 Without `note`, `lang=` only tags: there is no dictionary and no lexicon check.
 `package-build lint` checks at the key that `note` names a language note.
 
+**A language names its script.** Most tongues are written in one script, so the
+language note says which, as one map and one face:
+
+```yaml
+data:
+  writtenIn: { map: semaron, font: semaron-kuriale }
+```
+
+A run marked with the language alone then takes both: `[Zaron lonak]{lang=vyl}`
+is mapped through Semaron and checked against Vylari exactly as
+`[Zaron lonak]{lang=vyl font=semaron-kuriale map=semaron}` is, and so is a div,
+a verse fence or a `scroll` fence marked `lang=vyl`. A run that states one of
+the two keys keeps it, and takes the other from the language only where the
+two agree: `font=` alone takes the language's map where that map is drawn in
+the face, and `map=` alone takes the language's face where the map is drawn in
+it. So a tongue written in several scripts states its usual one, and a run in
+another names that script's keys. A language whose note states no `writtenIn`
+only tags, as above. The checks are at the key:
+
+> `` `data.writtenIn.map` is `semoran`, which no mapping note's `data.map.name` declares; did you mean `semaron`? ``
+
+> `` `data.writtenIn.font` is `teng-chou`, which the map `semaron` is not drawn in; it is drawn in `semaron-kuriale` ``
+
 **A run inherits from its passage and overrides it.** A span inside a marked
 div or fence takes the passage's keys, and its own keys win. A Khelathi phrase
 inside a Vylari poem is checked against Khelathi's lexicon and tagged Khelathi
@@ -805,8 +828,8 @@ Lokamen lonak zaron.
 
 **The stress rule** is `data.sounds.stress`, `{ two, longer, mark }`. `two`
 (`first` or `last`) places the stress in a word of two syllables; `longer`
-(`antepenultimate`, `penultimate` or `final`) places it in a word of three or
-more, counted from its end; `mark` (`acute`, `grave` or `circumflex`) is a
+(`first`, `antepenultimate`, `penultimate` or `final`) places it in a word of
+three or more, on its first syllable or counted from its end; `mark` (`acute`, `grave` or `circumflex`) is a
 diacritic that moves the stress to the syllable it sits on. Syllables are vowel
 groups: a vowel is a letter whose base is `a`, `e`, `i`, `o` or `u`, and a pair
 that the language lists in `data.sounds.syllables.vowelPairs` is one syllable.
@@ -850,6 +873,43 @@ A repeated metre name is an error too:
 
 > `` `data.metres[1].name` is `trimeter`, which this note declares twice; a metre's name is unique ``
 
+## Scripts written in columns
+
+A script written in vertical columns, read from the right, states it on its
+script note:
+
+```yaml
+data:
+  script:
+    fonts: [teng-chou]
+    emphasis: rubric
+    direction: vertical-rl
+```
+
+A passage in that script goes in a `scroll` fence. Its lines are joined into
+paragraphs, and each paragraph starts at the top of a fresh column. `rows=`
+sets the characters in a column and `cols=` the columns in a panel:
+
+````markdown
+```scroll {rows=25 cols=12 lang=tsu map=tengchou}
+chen teng chou hing
+tan tsou dou rou
+
+gen chei chou tsuen
+```
+````
+
+Where the Tantsou note states `writtenIn: { map: tengchou, font: teng-chou }`,
+` ```scroll {rows=25 cols=12 lang=tsu} ` is enough.
+
+The site, the preview and Foundry set it in columns, in a panel that scrolls
+sideways from the right. The book draws it as panel images from the face's
+outlines, each with its roman text as alt text. A span in the same script stays
+horizontal, inline in its line. A `scroll` fence in a script that states no
+direction is an error. See
+[scrolls](../authoring/links-and-markup.md#scrolls) for every attribute, the
+defaults on each target and the errors.
+
 ## The core vocabulary
 
 A setting can name the concepts every one of its languages has a word for, and
@@ -907,8 +967,9 @@ whose notes set no text in a face, ships none of it.
 `package-build transliterate <map> [--lang <language>] [--font <slug>] [--hex] [text..]`
 maps a passage exactly as the build maps a run marked `map=<map> lang=<language>
 font=<slug>`. The text is the words given; `-` or none reads standard input.
-`--font` is required when the mapping lists more than one face, and `--hex`
-prints `U+XXXX` code points separated by spaces.
+`--font` defaults to the language's `writtenIn` face where the mapping is drawn
+in it, and is otherwise required when the mapping lists more than one face.
+`--hex` prints `U+XXXX` code points separated by spaces.
 
 ```console
 $ package-build transliterate semaron --lang vyl --hex zaron lonak
@@ -920,8 +981,9 @@ U+F0246 U+F0230 U+F023F U+F023D U+F023C
 The first run writes `zaron` by its exception, and the second, with no
 `--lang`, spells it by the rows.
 
-`package-build lexicon <language> --map <map> [--font <slug>] [--derived] [--json]`
-lists every word of the language with its native form, tab-separated: the form,
+`package-build lexicon <language> [--map <map>] [--font <slug>] [--derived] [--json]`
+lists every word of the language with its native form under the map, or under
+the language's `writtenIn` script when `--map` is left out, tab-separated: the form,
 the native form, `exception` or `rows`, the class and the gloss. `--derived`
 adds the forms the language's rules derive, each with the word it comes from,
 `--json` prints an array instead, and under a logographic map the third column

package/docs/reference/format-details.md

@@ -1993,7 +1993,7 @@ errors.
 
 - **`lang=`** is a name declared in [`languages`](../configuration.md#languages),
   and otherwise a BCP 47 tag checked for its form alone. It gives the language
-  tag and changes nothing else.
+  tag, and the language's script where its note names one.
 - **`font=`** is a face of the installed `@heroiclands/fonts`, named by its
   `fonts.json` class without `hl-`, or `mono`, `serif` or `sans`.
 - **`map=`** is the `data.map.name` of a [mapping note](#mapping-notes). The
@@ -2003,6 +2003,14 @@ errors.
 - **`lang=` with `map=`** reads the language's lexicon first, when
   [`languages.<name>.note`](../configuration.md#languages) names its language
   note: see [a map reads the dictionary first](#a-map-reads-the-dictionary-first).
+- **`lang=` without `map=` or `font=`** takes the map and the face its
+  language note names in `data.writtenIn`, where the note states one. A run
+  that states `font=` alone takes the language's map only where the map is
+  drawn in that face, and one that states `map=` alone takes the language's
+  face only where that map is drawn in it. A run stating both takes nothing.
+  The default is read after a div or fence has given the run its keys, and is
+  its own language's. See
+  [a language's script](../authoring/links-and-markup.md#a-languages-script).
 
 **A face draws the code points its `fonts.json` entry lists in `codepoints`,
 and whitespace.** After the map, any other character in a run set in a face is
@@ -2022,9 +2030,10 @@ with a real language's tag alone keeps its Markdown. See
 [marking language, font and mapping](../authoring/links-and-markup.md#marking-language-font-and-mapping).
 
 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
+when the body marks nothing. Every entry has exactly `kind` (`span`, `block`, `scroll` or
 `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
+`map` as written, its own or inherited, else its language's `data.writtenIn`
+(a scroll fence that names no face takes its map's), `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
 key, so tags that differ only in case are separate values. This is derived
@@ -2364,8 +2373,9 @@ 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`:
+A `skill` note of `subType: script` states the faces its script is written in,
+how the script marks a stressed word, and the direction it is written in, in
+`data.script`:
 
 ```yaml
 data:
@@ -2381,6 +2391,25 @@ data:
   (or `_…_` and `__…__`) inside a run in one of the faces.
 - **`strongEmphasis`**, optional, is `rubric` or `overline`, and sets `**…**`
   alone.
+- **`direction`**, optional, is `vertical-rl` for a script written in columns,
+  top to bottom, with the columns read from the right. A
+  [`scroll` fence](../authoring/links-and-markup.md#scrolls) sets text in
+  such a script, and is an error in any other. A script that states no
+  direction is written in lines.
+
+A `skill` note of `subType: language` may state `data.writtenIn`, the script
+the language is written in: `map`, the `data.map.name` of a mapping note, and
+`font`, one of the faces that map lists, both required.
+
+```yaml
+data:
+  writtenIn: { map: semaron, font: semaron-kuriale }
+```
+
+A run marked with the language alone is mapped by `map` and set in `font`, as
+[text marked with a language, a font or a map](#text-marked-with-a-language-a-font-or-a-map)
+describes. A face a language's `writtenIn` names counts as used, so the
+package's fonts are delivered for it.
 
 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
@@ -2410,10 +2439,18 @@ 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.direction` should be `vertical-rl`, but reads "vertical" ``
+
 > `` `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.writtenIn` names the script a language is written in, and this note's `subType` is not `language` ``
+
+> `` `data.writtenIn.map` is `semoran`, which no mapping note's `data.map.name` declares; did you mean `semaron`? ``
+
+> `` `data.writtenIn.font` is `teng-chou`, which the map `semaron` is not drawn in; it is drawn in `semaron-kuriale` ``
+
 > `` `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 ``
@@ -3546,15 +3583,15 @@ for the keys.
 | `tongues`        | `data.tongues`                  | `tag`, `meaning`, and `tongue_language`, the tongue's `language`                                                                                                                                                                                                                                                                                                           |
 | `retired`        | `data.retired`                  | `form`, `instead` (always a list, `NULL` where nothing is written instead), `why`                                                                                                                                                                                                                                                                                          |
 | `scope`          | `data.scope`                    | No `position`: `kind`, the key the value is under (`folders`, `cultures`, `lore`, `parents`, `addresses`, `paths`, `types` or `skip`), and `value`, an Address in its canonical form or a path or a type                                                                                                                                                                   |
-| `letters`        | `data.sounds.letters`           | `letters` (a list), `kind`, `like`, `place`, `tongue` (a list, `NULL` for every tongue)                                                                                                                                                                                                                                                                                    |
+| `letters`        | `data.sounds.letters`           | `letters` (a list), `kind`, `like`, `place`, `ipa`, `tongue` (a list, `NULL` for every tongue); a [spelling guide's](#a-spelling-guides-sounds) rows too, keyed by the guide                                                                                                                                                                                               |
 | `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`: `two`, `longer` and `mark` (`NULL` where unstated), one row per language stating it                                                                                                                                                                                                                                                                         |
-| `finals`         | `data.sounds.finals`            | `final`, `like`                                                                                                                                                                                                                                                                                                                                                            |
+| `finals`         | `data.sounds.finals`            | `final`, `like`, `ipa`                                                                                                                                                                                                                                                                                                                                                     |
 | `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`                                                                                                                                                                                                                                                                                                                         |
 | `joins`          | `data.sounds.joins`             | `meeting`, `rule`, `letters` (a list), `where`                                                                                                                                                                                                                                                                                                                             |
-| `marks`          | `data.sounds.marks`             | `mark`, `letters` (a list), `kind`, `limit`                                                                                                                                                                                                                                                                                                                                |
+| `marks`          | `data.sounds.marks`             | `mark`, `letters` (a list), `kind`, `limit`; a spelling guide's rows too, keyed by the guide                                                                                                                                                                                                                                                                               |
 | `skeleton`       | `data.sounds.skeleton`          | `second` (a list, `[any]` for every other), `between`                                                                                                                                                                                                                                                                                                                      |
 | `frames`         | `data.sounds.frames`            | `frame`, `shape`, `class` (a list), `makes`, `examples` (a list of `{ root, form }`)                                                                                                                                                                                                                                                                                       |
 | `read_past`      | `data.sounds.readPast`          | `written`, `readAs`, `what`                                                                                                                                                                                                                                                                                                                                                |
@@ -3616,7 +3653,7 @@ 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 `verse`.                                                                  |
+| `kind`   | `VARCHAR` | `span`, `block`, `verse` or `scroll`.                                                        |
 | `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`.                                        |
@@ -6181,12 +6218,13 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `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, kind, like?, place?, ipa?, 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.letters[].ipa`                     | `string`                                                                                                                       | The sounds they write, in the International Phonetic Alphabet, as `ʃ`                                                                                                                          |
+| `sounds.letters[].tongue`                  | `string` or `string[]`                                                                                                         | The tongues that write them, each a tag `tongues` declares or a language note's Address; 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                                                                                                                                        |
@@ -6198,11 +6236,12 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `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.longer`                     | `first`, `antepenultimate`, `penultimate` or `final`, required                                                                 | The stressed syllable of a word of three or more: the first, or 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, like, ipa? }[]`                                                                                                      | 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.finals[].ipa`                      | `string`                                                                                                                       | Its sound, in the International Phonetic Alphabet                                                                                                                                              |
 | `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                                                                                                                                                       |
@@ -6332,10 +6371,14 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `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)                                                      |
+| `writtenIn`                                | `{ map, font }`                                                                                                                | `language` only: the script the language is written in, which a run marked with the language alone takes — see [script notes and emphasis](#script-notes-and-emphasis)                         |
+| `writtenIn.map`                            | `string`, required                                                                                                             | The `data.map.name` of a mapping note                                                                                                                                                          |
+| `writtenIn.font`                           | `string`, required                                                                                                             | A face the map lists                                                                                                                                                                           |
+| `script`                                   | `{ fonts, emphasis, strongEmphasis?, direction? }`                                                                             | `script` only: the faces the script is written in, how it marks emphasis and its direction — 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`                                                                                                                                                             |
+| `script.direction`                         | `vertical-rl`                                                                                                                  | Written in columns, top to bottom, read from the right, which a [`scroll` fence](../authoring/links-and-markup.md#scrolls) sets                                                                |
 
 #### A language's words
 
@@ -6815,8 +6858,11 @@ unless `types` is stated and leaves its type out, or `skip` names it.
 
 **`sounds` states the letters and the rules a word keeps.** `letters` gives
 each letter or group of letters, the kind of sound it writes, what it sounds
-like, where in the mouth it is made and, in a language whose tongues write
-differently, the tongues that write it. A row that states only a kind and a
+like, where in the mouth it is made, its sound in the International Phonetic
+Alphabet as `ipa` and, in a language whose tongues write differently, the
+tongues that write it. Each `tongue` is a tag `tongues` declares, or else the
+Address of a language note, so a row can name another language's note
+directly. A row that states only a kind and a
 place — one cell of a grid of consonants by manner and place — states no
 `like`. `edges` gives the sounds that may stand at each edge of a word, one
 entry per edge, the edge from a closed list:
@@ -6846,14 +6892,15 @@ closed list where its values are words:
 
 - `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`,
+  the stressed syllable of a word of three or more, `first`, or 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.
+- `finals`: the syllable finals, each with what it sounds like and, as `ipa`,
+  its sound in the International Phonetic Alphabet, for a language whose
+  syllables are parsed by them.
 - `syllables`: what a syllable opens on (`single`, a single consonant), the
   `codas` that close a syllable and the `finals` that close a word (a list, or
   `any`), the `doubled` consonants and `vowelPairs` a word may hold (none where
@@ -7040,6 +7087,40 @@ FROM edges WHERE language = 'thalorna-note-skill-dunharlng' ORDER BY position
 `cognates` read the same way; [content tables](#content-tables) gives every
 relation's columns.
 
+#### A spelling guide's sounds
+
+One spelling guide can state the letters every tongue of a setting is written
+by. A `doc` note of any subType may state `data.sounds` with `letters` and
+`marks` alone, each row with a language note's keys, `ipa` included:
+
+```yaml
+type: doc
+subType: reference
+data:
+  sounds:
+    letters:
+      - { letters: [sh], kind: consonant, like: ship, ipa: ʃ }
+      - {
+          letters: [ui],
+          kind: vowel pair,
+          like: gooey,
+          ipa: ui,
+          tongue: [skill-tantsoulng, skill-jurthatlng],
+        }
+    marks:
+      - { mark: diaeresis, letters: [ë], kind: length, limit: any }
+```
+
+A guide declares no tags, so a letter row's `tongue` names language notes by
+their Addresses, and each must resolve to a `skill` of `subType: language`. Any
+other key of `sounds` is an error at the key, since the rules of a word belong
+to its language. The rows are rows of the `letters` and `marks` relations, with
+the guide's Address as `language`. Each of these is an error at the value:
+
+> `` `data.sounds.letters[1].tongue` names `vylari`, which is no language note's Address; a spelling guide names each tongue by its language note ``
+
+> `` `data.sounds.letters[1].tongue[1]` names thalorna-note-skill-riding, which is not a skill whose subType is language ``
+
 if a `sohl` property is present, a SoHL item of type "skill" is created.
 
 If an `hm3` property is present, an HM3 item of type "skill" is created.
@@ -8190,35 +8271,48 @@ Content prepared to be played — a situation with its cast, places, and possibl
 - 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.
 - 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 |
+| `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                      |
+| `sounds`                    | `{ letters?, marks? }`                               | A spelling guide's letters and marks, for every tongue of the setting; any subType. See [a spelling guide's sounds](#a-spelling-guides-sounds) |
+| `sounds.letters`            | `{ letters, kind, like?, place?, ipa?, tongue? }[]`  | The letters, each row's keys as a language note's `sounds.letters`                                                                             |
+| `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 `vowel pair`                                                                                  |
+| `sounds.letters[].like`     | `string`                                             | What they sound like                                                                                                                           |
+| `sounds.letters[].place`    | `string`                                             | Where in the mouth they are made                                                                                                               |
+| `sounds.letters[].ipa`      | `string`                                             | The sounds they write, in the International Phonetic Alphabet                                                                                  |
+| `sounds.letters[].tongue`   | an Address, or a list of them                        | The language notes that write the letters; every tongue where absent                                                                           |
+| `sounds.marks`              | `{ mark, letters, kind, limit }[]`                   | The marks written on the letters, each row's keys as a language note's `sounds.marks`                                                          |
+| `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                                                                                                                      |
 
 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.