@heroiclands/package-build 25.0.0 → 25.1.0

package/docs/reference/note-types.md

@@ -468,8 +468,8 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `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.roman`            | a literal NFC string of permitted characters, including case, accents, digits and punctuation                                                | The exact Roman source characters this language permits, each once. No ranges, case expansion or inherited inventory; spaces and line breaks are structural. An empty string declares no written characters. Required on each configured language note.                                                                                                                                               |
-| `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.roman`            | a literal NFC string of additional source characters, including exact letter case and digits                                                 | The additional Roman source characters the language permits, each once. Standard punctuation and structural whitespace remain available. No ranges, case expansion or inherited inventory. An empty string declares no additions. Required on each configured language note.                                                                                                                          |
+| `data.grammar`          | a map — `{ plural?, verbs?, agreement?, participles?, native? }`                                                                             | Optional noun plurals, one verb pattern, agreement, participles and the endings' native writings, for dictionary presentation, language word checks and encodings. 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.                                                                                                                                                                                                                                                                                                                            |
@@ -484,8 +484,7 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `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.writtenIn`        | a map — `{ map, font }`                                                                                                                      | The script the language is written in, as the default map and face selected by a run with explicit `lang=` and `.nativefont`; a run's own `map=` or `font=` overrides its half. Only a skill of `subType: language` states it.                                                                                                                                                                        |
-| `data.script`           | a map — `{ fonts, emphasis, strongEmphasis?, direction? }`                                                                                   | A script note's faces, how it marks emphasis and the direction it is written in. Only a skill of `subType: script` states it.                                                                                                                                                                                                                                                                         |
+| `data.script`           | a map — `{ fonts, emphasis, direction? }`                                                                                                    | A script note's faces, how it marks emphasis and the direction it is written in. 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.
 
@@ -513,10 +512,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. 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, or as a logographic map writes it.                                                                                                                                                                                                                      |
+| `data.words[].native`                     | a list of `{ enc, font?, text }`                                                                          | no       | The word's own writing for an encoding and optional face. It precedes complete parts and the encoding's rows; an entry for a face precedes an unqualified entry. Derived forms can use the stem and explicitly written grammatical endings.                                                                                              |
+| `data.words[].native[].enc`               | an encoding document Address                                                                              | yes      | The encoding the native form is written for.                                                                                                                                                                                                                                                                                             |
+| `data.words[].native[].font`              | a face the encoding lists                                                                                 | no       | The one face the native form is for; unstated, it is for every face the encoding lists, and a form stated for a face wins over it there.                                                                                                                                                                                                 |
+| `data.words[].native[].text`              | the word in the script, as the encoding's characters                                                      | yes      | The word as the script writes it, where the encoding's rows would write it otherwise, or by an explicit native spelling.                                                                                                                                                                                                                 |
 | `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.                                                                                                                                                                                                                                                                                                                    |
@@ -531,10 +530,10 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `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.affixes[].native`                   | a list of `{ enc, font?, text }`                                                                          | no       | The affix's writing under an encoding, which a word whose `built` names the affix is written with.                                                                                                                                                                                                                                       |
+| `data.affixes[].native[].enc`             | an encoding document Address                                                                              | yes      | The encoding the native form is written for.                                                                                                                                                                                                                                                                                             |
+| `data.affixes[].native[].font`            | a face the encoding lists                                                                                 | no       | The one face the native form is for; unstated, it is for every face the encoding lists, and a form stated for a face wins over it there.                                                                                                                                                                                                 |
+| `data.affixes[].native[].text`            | the word in the script, as the encoding's characters                                                      | yes      | The word as the script writes it, where the encoding's rows would write it otherwise, or by an explicit native spelling.                                                                                                                                                                                                                 |
 | `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.                                                                                                                                                                                                                                                                                 |
@@ -554,10 +553,10 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `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`                     | a list of `{ ending, enc, font?, text }`                                                                  | no       | Under an encoding, the signs a noun's plural or a verb's present form is written with after its stem's writing, one entry per ending, encoding 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[].enc`               | an encoding document Address                                                                              | yes      | The encoding the ending is written for.                                                                                                                                                                                                                                                                                                  |
+| `data.grammar.native[].font`              | a face the encoding lists                                                                                 | no       | The one face the writing is for; unstated, it is for every face the encoding 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.                                                                                                                                                                                                                                                                                                           |
@@ -712,11 +711,8 @@ 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.writtenIn.map`                      | a mapping note's `data.map.name`                                                                          | yes      | The map the language's text is written by.                                                                                                                                                                                                                                                                                               |
-| `data.writtenIn.font`                     | an installed face's slug                                                                                  | yes      | The face the text is set in, one the map is drawn in.                                                                                                                                                                                                                                                                                    |
 | `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.                                                                                                                                                                                                                                                                                    |
+| `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 `.emph` and accepted English emphasis inside a run in one of its faces, unless the run's language states its own `emphasis`.                                                                                                    |
 | `data.script.direction`                   | `vertical-rl`                                                                                             | no       | How the script is written: `vertical-rl` is columns, top to bottom, read from the right, which a `scroll` fence sets. A script stating none is written in lines.                                                                                                                                                                         |
 
 **System mappings**
@@ -1001,53 +997,74 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 
 **Subtypes:** `rules`, `userguide`, `reference`, `howto`, `concept`, `settingguide`, `post`.
 
-| 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.sounds`   | a map — `{ letters?, marks? }`                         | A spelling guide's letters and the marks written on them, for every tongue of the setting: each letter row's `tongue` names the language notes that write it.               |
-| `data.map`      | a map — `{ name, logographic?, vowels?, fonts, rows }` | A mapping, which native text marked with `lang=`, `.nativefont` and its `map=` 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).  |
+| Field           | Shape                                | Meaning                                                                                                                                                                    |
+| --------------- | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `data.language` | a configured language alias          | The configured language alias an encoding document writes.                                                                                                                 |
+| `data.font`     | an installed font slug               | The encoding's installed font, which supplies all glyph codes.                                                                                                             |
+| `data.accepts`  | a list of characters or ranges       | Accepted Roman letters and additions to standard punctuation.                                                                                                              |
+| `data.vowels`   | a string                             | The letters a contextual vowel match reads as vowels.                                                                                                                      |
+| `data.mappings` | Roman strings to glyph codes         | Roman source strings mapped to codes published by the selected font.                                                                                                       |
+| `data.rules`    | the closed encoding rules vocabulary | Executable normalization, matching, case, stress, vowel groups, accents and contextual mappings.                                                                           |
+| `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.sounds`   | a map — `{ letters?, marks? }`       | A spelling guide's letters and the marks written on them, for every tongue of the setting: each letter row's `tongue` names the language notes that write it.              |
+| `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.sounds.letters`            | list of `{ letters, kind, like?, place?, ipa?, tongue? }`    | no       | The letters the language writes, and the sounds they stand for.                                                                                                                                        |
-| `data.sounds.letters[].letters`  | a list of letters                                            | yes      | The letters or digraphs the row describes, as written.                                                                                                                                                 |
-| `data.sounds.letters[].kind`     | a string, such as `consonant` or `long vowel`                | yes      | What kind of sound they write.                                                                                                                                                                         |
-| `data.sounds.letters[].like`     | a string                                                     | no       | What they sound like; absent where the row states only their kind and place.                                                                                                                           |
-| `data.sounds.letters[].place`    | a string, such as `lips` or `tongue-tip`                     | no       | Where in the mouth they are made.                                                                                                                                                                      |
-| `data.sounds.letters[].ipa`      | a string in the International Phonetic Alphabet, such as `ʃ` | no       | The sounds they write, in the International Phonetic Alphabet.                                                                                                                                         |
-| `data.sounds.letters[].tongue`   | a tag or a language note's Address, or a list of them        | no       | The tongues that write them, each a tag `data.tongues` declares or the Address of a language note; every one where absent. A `doc` note's rows name language notes only.                               |
-| `data.sounds.marks`              | list of `{ mark, letters, kind, limit }`                     | no       | The marks the language writes on its letters.                                                                                                                                                          |
-| `data.sounds.marks[].mark`       | a string, such as `acute`                                    | yes      | The mark's name.                                                                                                                                                                                       |
-| `data.sounds.marks[].letters`    | a list of letters                                            | yes      | The letters that carry it.                                                                                                                                                                             |
-| `data.sounds.marks[].kind`       | one of stress, length, apart                                 | yes      | What the mark says of its letter.                                                                                                                                                                      |
-| `data.sounds.marks[].limit`      | one of one, any                                              | yes      | How many a word may carry: `one` at most, or `any`.                                                                                                                                                    |
-| `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.                                                                                                                                                            |
-| `data.map.rows[].to`             | a string, which may be empty                                 | yes      | What the row writes in their place; empty to drop them.                                                                                                                                                |
-| `data.map.rows[].before`         | string                                                       | no       | `vowel` or `consonant`: what must follow the match for the row to apply.                                                                                                                               |
-| `data.map.rows[].at`             | string                                                       | no       | `start` or `end`: where the match must sit for the row to apply.                                                                                                                                       |
-| `data.map.fonts`                 | list of `{ font, rows? }`                                    | yes      | The faces the map is drawn in, at least one, each with any rows of its own. A run in another face is refused, and each face must draw every character its rows and the lexicon's native forms write.   |
-| `data.map.fonts[].font`          | an installed face's slug                                     | yes      | A face the map is drawn in, by the slug `font=` names it by.                                                                                                                                           |
-| `data.map.fonts[].rows`          | list of `[from, to]` or `{ from, to, before?, at? }`         | no       | Rows for this face alone, tried before the shared `rows`; the same shapes and conditions.                                                                                                              |
-| `data.map.fonts[].rows[].from`   | a string of one or more characters                           | yes      | The one or more characters the row matches.                                                                                                                                                            |
-| `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.                                                                   |
+| Key                                                    | Shape                                                        | Required | Meaning                                                                                                                                                                  |
+| ------------------------------------------------------ | ------------------------------------------------------------ | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `data.rules.normalization`                             | "NFC"                                                        | yes      | Required value: "NFC".                                                                                                                                                   |
+| `data.rules.matching`                                  | "longest-first"                                              | yes      | Required value: "longest-first".                                                                                                                                         |
+| `data.rules.case`                                      | a map                                                        | no       | Case handling for letters and consonant groups.                                                                                                                          |
+| `data.rules.case.single-letter`                        | "preserve"                                                   | yes      | Required value: "preserve".                                                                                                                                              |
+| `data.rules.case.consonant-group`                      | "lowercase-or-initial-uppercase"                             | yes      | Required value: "lowercase-or-initial-uppercase".                                                                                                                        |
+| `data.rules.case.other-group-cases`                    | "forbidden"                                                  | yes      | Required value: "forbidden".                                                                                                                                             |
+| `data.rules.stress`                                    | a map                                                        | no       | The font's nonprinting stress modifier after an acute vowel.                                                                                                             |
+| `data.rules.stress.modifier`                           | a string                                                     | yes      | The font code for U+E0114.                                                                                                                                               |
+| `data.rules.stress.position`                           | "after-stressed-vowel"                                       | yes      | Required value: "after-stressed-vowel".                                                                                                                                  |
+| `data.rules.stress.printing`                           | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.stress.effect`                             | "stress-only"                                                | yes      | Required value: "stress-only".                                                                                                                                           |
+| `data.rules.stress.changes-sound`                      | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.stress.changes-length`                     | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.stress.vowel-group-position`               | "first-vowel"                                                | yes      | Required value: "first-vowel".                                                                                                                                           |
+| `data.rules.vowel-groups`                              | a map                                                        | no       | Explicit recognized vowel groups and their acute placement.                                                                                                              |
+| `data.rules.vowel-groups.reading`                      | "established"                                                | yes      | Required value: "established".                                                                                                                                           |
+| `data.rules.vowel-groups.allow-splitting`              | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.vowel-groups.unrecognized-adjacent-vowels` | "separate"                                                   | yes      | Required value: "separate".                                                                                                                                              |
+| `data.rules.vowel-groups.groups`                       | a list of vowel groups                                       | yes      | The complete authored group inventory.                                                                                                                                   |
+| `data.rules.diaeresis`                                 | a map                                                        | no       | Whether diaeresis mappings are allowed.                                                                                                                                  |
+| `data.rules.diaeresis.allowed`                         | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.grave-accent`                              | a map                                                        | no       | Whether grave-accent mappings are allowed.                                                                                                                               |
+| `data.rules.grave-accent.allowed`                      | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `data.rules.contextual-mappings`                       | a list of conditional mappings                               | no       | Before-vowel alternatives applied before unconditional mappings.                                                                                                         |
+| `data.rules.contextual-mappings[].match`               | a string                                                     | yes      | The source sequence.                                                                                                                                                     |
+| `data.rules.contextual-mappings[].before`              | "vowel"                                                      | yes      | Required value: "vowel".                                                                                                                                                 |
+| `data.rules.contextual-mappings[].emit`                | a glyph code or list of codes                                | yes      | The font codes written by this alternative.                                                                                                                              |
+| `data.rules.y`                                         | a map                                                        | no       | The consonant reading of y.                                                                                                                                              |
+| `data.rules.y.kind`                                    | "consonant"                                                  | yes      | Required value: "consonant".                                                                                                                                             |
+| `data.rules.y.sound`                                   | "y in yes"                                                   | yes      | Required value: "y in yes".                                                                                                                                              |
+| `data.rules.y.vowel-reading`                           | false                                                        | yes      | Required value: false.                                                                                                                                                   |
+| `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.sounds.letters`                                  | list of `{ letters, kind, like?, place?, ipa?, tongue? }`    | no       | The letters the language writes, and the sounds they stand for.                                                                                                          |
+| `data.sounds.letters[].letters`                        | a list of letters                                            | yes      | The letters or digraphs the row describes, as written.                                                                                                                   |
+| `data.sounds.letters[].kind`                           | a string, such as `consonant` or `long vowel`                | yes      | What kind of sound they write.                                                                                                                                           |
+| `data.sounds.letters[].like`                           | a string                                                     | no       | What they sound like; absent where the row states only their kind and place.                                                                                             |
+| `data.sounds.letters[].place`                          | a string, such as `lips` or `tongue-tip`                     | no       | Where in the mouth they are made.                                                                                                                                        |
+| `data.sounds.letters[].ipa`                            | a string in the International Phonetic Alphabet, such as `ʃ` | no       | The sounds they write, in the International Phonetic Alphabet.                                                                                                           |
+| `data.sounds.letters[].tongue`                         | a tag or a language note's Address, or a list of them        | no       | The tongues that write them, each a tag `data.tongues` declares or the Address of a language note; every one where absent. A `doc` note's rows name language notes only. |
+| `data.sounds.marks`                                    | list of `{ mark, letters, kind, limit }`                     | no       | The marks the language writes on its letters.                                                                                                                            |
+| `data.sounds.marks[].mark`                             | a string, such as `acute`                                    | yes      | The mark's name.                                                                                                                                                         |
+| `data.sounds.marks[].letters`                          | a list of letters                                            | yes      | The letters that carry it.                                                                                                                                               |
+| `data.sounds.marks[].kind`                             | one of stress, length, apart                                 | yes      | What the mark says of its letter.                                                                                                                                        |
+| `data.sounds.marks[].limit`                            | one of one, any                                              | yes      | How many a word may carry: `one` at most, or `any`.                                                                                                                      |
+| `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
 

package/docs/source-preview.md

@@ -39,6 +39,14 @@ picture, marked text is mapped and set in its face, an icon is drawn, and a
 caption is numbered with its asset's role, so a map is a **Map**. A query, which
 a buffer cannot run, stays highlighted source in both views.
 
+With an index, a marked-text run that cannot be set produces an error finding
+and sets the result's `ok` to `false`. The preview still returns recoverable
+HTML, including the Roman text of a failed native-script run. Findings identify
+the supplied `file`, severity, message, line and column in the authored buffer,
+including its frontmatter lines; expansion does not shift their positions.
+Hosts can display that HTML beside the findings. Without an index, marked text
+stays highlighted source and produces no run findings.
+
 Wikilinks, image and portrait links retain their complete source: blue brackets,
 purple addresses, bold foreground labels and grey attributes. Entire spans are bold, including their visible brackets and attributes.
 Definition-list terms are bold and definitions use normal text. SQL and pagelist fences remain grey source;

package/e2e.mjs

@@ -799,7 +799,7 @@ export function suiteExecutables(command) {
 }
 
 /** The Chrome for Testing build shared by local and CI Cypress runs. */
-export const CHROME_BUILD_ID = "158.0.8110.0";
+export const CHROME_BUILD_ID = "158.0.8122.0";
 
 /**
  * The browser cache survives reseeding and container teardown.

package/engine/base-compiler.mjs

@@ -633,9 +633,24 @@ export class BasePackCompiler {
      * @throws {Error} When `findings` is non-empty, after reporting all of them.
      */
     reportConvertBodyFindings(findings) {
+        this.externalBodyFindings ??= new Set();
         for (const finding of findings) {
+            if (finding.file && finding.file !== this.currentNote?.absPath) {
+                const key = JSON.stringify([
+                    finding.file,
+                    finding.line,
+                    finding.column,
+                    finding.message,
+                ]);
+                if (this.externalBodyFindings.has(key)) continue;
+                this.externalBodyFindings.add(key);
+            }
             this.errorCount++;
-            this.noteError(finding.message, { line: finding.line, column: finding.column });
+            this.noteError(finding.message, {
+                file: finding.file,
+                line: finding.line,
+                column: finding.column,
+            });
         }
         if (findings.length) {
             const error = new Error(
@@ -670,10 +685,13 @@ export class BasePackCompiler {
         const bodyColumn = this.currentNote?.bodyColumn ?? 1;
         // A finding's body position, in the file. The parser trims the body,
         // so only its first line is offset by the column the body starts at.
-        const inFile = ({ line, column }) => ({
-            line: bodyLine + line - 1,
-            column: line === 1 && column !== undefined ? bodyColumn + column - 1 : column,
-        });
+        const inFile = ({ file, line, column }) =>
+            file ?
+                { file, line, column }
+            :   {
+                    line: bodyLine + line - 1,
+                    column: line === 1 && column !== undefined ? bodyColumn + column - 1 : column,
+                };
         const syntax = this.corpus?.syntax;
         const scanned = syntax?.(body);
         for (const secretError of [
@@ -893,12 +911,12 @@ export class BasePackCompiler {
      * naming the file alone beats naming a line that is not the problem.
      *
      * @param {string} message - What is wrong, in one sentence.
-     * @param {{line?: number, column?: number}} [position] - Where, if known.
+     * @param {{file?: string, line?: number, column?: number}} [position] - Where, if known.
      * @returns {void}
      */
     noteWarn(message, position) {
         emitDiagnostic({
-            file: this.currentNote?.absPath,
+            file: position?.file ?? this.currentNote?.absPath,
             line: position?.line,
             column: position?.column,
             severity: "warning",
@@ -910,12 +928,12 @@ export class BasePackCompiler {
      * Reports an error about the note being compiled.
      *
      * @param {string} message - What is wrong, in one sentence.
-     * @param {{line?: number, column?: number}} [position] - Where, if known.
+     * @param {{file?: string, line?: number, column?: number}} [position] - Where, if known.
      * @returns {void}
      */
     noteError(message, position) {
         emitDiagnostic({
-            file: this.currentNote?.absPath,
+            file: position?.file ?? this.currentNote?.absPath,
             line: position?.line,
             column: position?.column,
             severity: "error",

package/engine/content-charset.mjs

@@ -125,6 +125,13 @@ export function isLetterTier(cp) {
  */
 export const TYPOGRAPHY = Object.freeze(
     new Set([
+        0x00ab, // « outer quotation open
+        0x00bb, // » outer quotation close
+        0x2039, // ‹ inner quotation open
+        0x203a, // › inner quotation close
+        0x203c, // ‼ imperative terminal
+        0x27e6, // ⟦ codage open
+        0x27e7, // ⟧ codage close
         0x2013, // – en dash
         0x2014, // — em dash
         0x2018, // ' left single quote
@@ -170,6 +177,7 @@ export const NOTATION = Object.freeze(
  */
 const SCRIPT_BLOCKS = Object.freeze([
     [0xf0000, 0xf2fff], // plane 15: Pirzath, Thuravark, Semaron, the reserved alphabets, Teng Chou
+    [0xf3000, 0xf3fff], // Ch'alish P'ilam Common
     [0x1e960, 0x1ec6f], // Zethu overflow, Qalezu, Zethu
     [0x1ecc0, 0x1ecff], // Qalezu catch-before forms
     [0x1ed50, 0x1ed7f], // Veldikko
@@ -195,7 +203,11 @@ export function isSettingScriptCodePoint(cp) {
  */
 export function isAllowedCodePoint(cp) {
     return (
-        isLetterTier(cp) || TYPOGRAPHY.has(cp) || NOTATION.has(cp) || isSettingScriptCodePoint(cp)
+        isLetterTier(cp) ||
+        TYPOGRAPHY.has(cp) ||
+        NOTATION.has(cp) ||
+        isSettingScriptCodePoint(cp) ||
+        (cp >= 0xe0100 && cp <= 0xe01ef)
     );
 }
 

package/engine/content-format.yaml

@@ -227,7 +227,6 @@ types:
             - negation
             - naming
             - emphasis
-            - writtenIn
             - script
         subTypes:
             - social
@@ -367,12 +366,17 @@ types:
             - encounter
     doc:
         data:
+            - language
+            - font
+            - accepts
+            - vowels
+            - mappings
+            - rules
             - culture
             - concepts
             - date
             - author
             - sounds
-            - map
             - metres
         subTypes:
             - rules

package/engine/content-index.mjs

@@ -106,7 +106,7 @@ import { AddressLink } from "./address-values.mjs";
 import { scanSpans } from "./content-spans.mjs";
 import { rebaseNameSpans } from "./name-markup.mjs";
 import { analyzeNameSpans } from "./names.mjs";
-import { fillWrittenIn, recordRuns } from "./run-rows.mjs";
+import { fillEncodingRuns, recordRuns } from "./run-rows.mjs";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -1074,6 +1074,8 @@ export function resolveCultures(
  *   calendar note's shortcode; see {@link module:engine/note-calendars}.
  * @param {string} [options.configFile] - The configuration file, where an
  *   unknown `defaultCalendar` is reported.
+ * @param {string} [options.rootDir] - Consumer package root for loading installed
+ *   encodings when filling language native-writing defaults.
  * @param {Readonly<Record<string, {tag: string}>>} [options.languages] - The
  *   configured languages, which give each run's `lang=` its tag.
  * @param {(key: string) => ({culture?: unknown}|undefined)} [options.foreignRecord] -
@@ -1095,6 +1097,7 @@ export function collectContentIndex(
         currentDate,
         defaultCalendar,
         configFile,
+        rootDir,
         languages,
         skipDirectories,
         assetsBase,
@@ -1252,7 +1255,7 @@ export function collectContentIndex(
 
     // A run marked with a language alone takes its language's script, which
     // is read once every language note is recorded.
-    fillWrittenIn(records, { languages, contentPackage });
+    fillEncodingRuns(records, { languages, contentPackage, rootDir });
 
     // Every note record exists and every Address in it is a tuple, so a parent
     // is found by its canonical address. Before the sort, which reads nothing
@@ -1489,6 +1492,7 @@ export function indexRecordsFor({
         return foreign.get(key);
     };
     return collectContentIndex(tree, {
+        rootDir: resolved.rootDir,
         contentPackage: resolved.contentPackage,
         currentDate: resolved.currentDate,
         defaultCalendar: resolved.defaultCalendar ?? undefined,

package/engine/content-links.mjs

@@ -648,6 +648,7 @@ export function buildLinkIndex(
     }
 
     return {
+        config,
         notes,
         frontmatterLinks,
         anchors,