@heroiclands/package-build 24.0.3 → 24.1.0

package/docs/authoring/links-and-markup.md

@@ -343,48 +343,58 @@ Foundry renders a secret section; the website renders an expandable spoiler, and
 
 ### Verse
 
-Use a code fence with the language `verse` to preserve verse lines and stanzas. Every nonblank source line
-is one verse line; blank lines separate stanzas. Inline emphasis, links and
-footnotes work as they do in prose. The fence itself adds no title, caption or
-number.
-
-Leading spaces indent individual verse lines. The least-indented nonblank line
-sets level zero for the whole poem, so a common indentation on every line has no
-visual effect. Each additional two spaces adds one level, up to `i8`; an odd
-extra space rounds down. Each medium sets the actual width of a level, with
-every higher level wider than the preceding one. Tabs anywhere in the poem are
-an error. Interior spaces are preserved on a best-effort basis.
-
-| Extra leading spaces | Indent class |
-| -------------------- | ------------ |
-| 0–1                  | none         |
-| 2–3                  | `i1`         |
-| 4–5                  | `i2`         |
-| 6–7                  | `i3`         |
-| 8–9                  | `i4`         |
-| 10–11                | `i5`         |
-| 12–13                | `i6`         |
-| 14–15                | `i7`         |
-| 16 or more           | `i8`         |
-
-For example, a line with four leading spaces and a line with six leading spaces
-render at levels zero and `i1` respectively. This also works when the entire
-fence is indented inside a list item. Verse is upright by default; use normal
-Markdown emphasis when italics are part of the poem.
+Use a code fence with the language `verse` to preserve verse lines and stanzas.
+Each nonblank source line is one verse line. A blank line separates verse units;
+`***` on a line by itself separates stanzas. Neither separator is numbered.
+The fence itself adds no title, caption or number.
+
+Leading periods set indentation: one `.` per level. They are removed
+from the displayed line. Leading spaces are ignored and do not set indentation.
+Periods inside the first inline span also set indentation when that span begins
+the line; periods in later spans are literal text. Interior spaces between text
+and spans are preserved. Tabs anywhere in the poem are an error. Each medium
+sets the actual width of an indent level, with every higher level wider than the
+preceding one.
+
+Levels 1 through 8 use the `i1`–`i8` indent classes. Deeper levels retain
+their full depth in the generated indent width.
+
+For example, `.A line` is indented one level, while `  ..A line` is indented
+two levels: the spaces do not count. Verse is upright by default. English text
+can use Markdown emphasis; emphasis inside a span whose effective language is
+not English is an error. See [emphasis in a script](#emphasis-in-a-script).
+
+A verse line can mix plain English, language-marked spans and more English on
+one authored line. Spaces are kept exactly as written between those runs; the
+spans add no spaces of their own. A period at the start of the first span also
+sets that line's indentation:
+
+````markdown
+```verse {lang=en}
+..The [boundary]{lang=en} is [thiruthriman]{lang=vyl} again.
+[.The boundary]{lang=en} is [thiruthriman]{lang=vyl} again.
+```
+````
+
+Both lines have one verse number apiece when numbering is enabled. In the
+second, the leading period inside the first span is removed and indents the
+whole line.
 
 ````markdown
 ```verse {form=ballad lang=en}
 The lantern burns beside the gate,
 The harbor sleeps below.
 
+***
+
 The keeper guards the road till dawn,
 And keeps a light aglow.
 ```
 ````
 
 The optional `form` attribute records the author's intent; the build does not
-infer stress, rhyme or pronunciation. `numstep` numbers the lines, and `col1` and
-`col2` set the poem in columns; see below. `lang` names the poem's language,
+infer stress, rhyme or pronunciation. `numstep` numbers the logical rows, and `cols`
+sets the poem's column count; see below. `lang` names the poem's language,
 `font` the font it is set in and `map` the mapping its text is rewritten by; see
 [marking language, font and mapping](#marking-language-font-and-mapping). An optional `#id`
 addresses the poem itself. There are no `title` or `lines` attributes, and no
@@ -423,6 +433,12 @@ Thiruthriman sorimamen, ul alathas kedis alatha valmazor,
 
 > ``this line has 4 beats (5 with secondary beats); the metre `hexameter` has 6``
 
+`scan=` uses the fence's one language to count beats. If a verse line contains
+a run in another language, the build does not scan that run with the fence
+language's stress rules; it reports an error at the line:
+
+> `` `scan=` counts one language’s beats; this verse line contains another language ``
+
 Beats are counted this way:
 
 - **Syllables** are vowel groups. A vowel is a letter whose base is `a`, `e`,
@@ -481,70 +497,58 @@ The lantern burns beside the gate,
 
 #### Verse in columns
 
-A poem can be set beside its translation, line for line. `col1=` names what
-the left column shows and `col2=` what the right column shows, and each
-column stacks one or more **entries**, joined by `:`. An entry is
-`language[/mapping[/font]]`:
+`cols=N` sets a positive whole number of columns and defaults to `1`. A
+single-column poem keeps its physical lines without column prefixes. For
+`cols` above one, every content line starts with its column number and one
+or more spaces. The prefix selects its cell and is not displayed.
 
-- **`language`** names a language the poem's lines give, as `lang=` does.
-- **`mapping`** names a [mapping note](#mapping-notes), which rewrites the
-  line before it is set. Left out, the line is set as written.
-- **`font`** names a face or a generic family, as `font=` does. Left out, the
-  line is set in the roman serif.
+A blank line ends a **logical verse row**. Within that row, numbers must be
+in `1..cols` and nondecreasing: finish one column before starting a higher
+one. Any column may be omitted; its empty cell remains in the grid. A column
+may hold any number of readings. Its first line uses the foreground color,
+and every subsequent line in that same column is grey. Each column starts
+its own foreground line, and the choice resets in the next row.
 
-A poem has at most two columns, and either may be left out. In every column
-the first entry is set in the normal tone and each later one in grey.
-
-With columns, the poem's body is written as **verse lines**, each a group of
-lines separated by a blank line. Each line of a group is a span giving the
-verse line in one language, `[text]{lang=…}`, or plain text in the poem's
-`lang=`. The spans of a group may come in any order: each entry takes the
-span in its own language. A line holding only `***` breaks the stanza.
-
-Here the left column sets the Vylari in Semaron Kuriale through the `semaron`
-mapping, and the right column gives the English over the Vylari in roman:
+This sparse three-column poem leaves the middle cell empty in its first row:
 
 ````markdown
-```verse {numstep=5 lang=vyl col1=vyl/semaron/semaron-kuriale col2=en:vyl}
-[Thiruthriman sorimamen,]{lang=vyl}
-[The hallowed boundary I sing,]{lang=en}
-
-[ul alathas kedis alatha valmazor, ul talothoi]{lang=vyl}
-[and the one who walked it, and the stones]{lang=en}
-
-***
+```verse {form=epic lang=en numstep=5 cols=3}
+1 [Thiruthriman sorimamen,]{.nativefont lang=vyl}
+3 [The hallowed boundary I sing,]{lang=en}
+3 [Thiruthriman sorimamen,]{lang=vyl}
 
-[set down in the grass of the six hills]{lang=en}
-lendthoi ir yormalis ol selthur malkothoi
-
-[before a wall stood on any of them.]{lang=en}
-pra kembothos us urkis ol alathoi thalezor.
+1 [ul alathas kedis alatha valmazor, ul talothoi]{.nativefont lang=vyl}
+2 [Nothing to say]{lang=en}
+3 [and the one who walked it, and the stones]{lang=en}
+3 [ul alathas kedis alatha valmazor, ul talothoi]{lang=vyl}
 ```
 ````
 
-The Vylari is written once, in roman, and the script is never typed: the
-first entry of `col1=` maps the Vylari line into Semaron, and the second entry
-of `col2=` sets the same line as written. The last two verse lines give their
-Vylari as plain text, which takes the poem's `lang=vyl`.
+The left cell uses Vylari's configured native script. The third cell contains
+an English reading in foreground and a separately authored Roman Vylari
+reading in grey. Language labels identify words; column numbers alone place
+them. `.nativefont`, `lang=`, `font=` and `map=` are written on the actual
+runs, so a Roman repeat makes its own presentation choice. Inline links and
+mixed-language spans stay in their authored order with their spaces intact.
 
-Every target sets each verse line as one row: its number, when the poem is
-numbered, then each column. Each row holds its columns level, so a long line
-on one side never puts the other out of step. On a narrow screen or a narrow
-journal, a row stacks its columns in order. A part set in a right-to-left face
-stays in its column and runs right to left within it. The book sets the poem
-as a grid with a row per verse line.
+`numstep=N` counts logical rows, not their individual readings. A standalone
+`***` separates stanzas, and column order resets after it as after a blank
+line. Leading periods after the number and its separating spaces set a
+reading's indent. Periods at the start of its first span also count; periods
+inside later spans remain text. For example:
 
-**The rules of a verse in columns:**
+```markdown
+1 [.Thiruthriman [the boundary]{lang=en} sorimamen]{lang=vyl}
+3 [The hallowed boundary I sing,]{lang=en}
+```
 
-- `font=` and `map=` belong to the entries, not to the poem.
-- Every verse line gives one span for each language its columns name, and
-  none for a language they do not.
-- A line of a verse in columns is not indented, and a span there takes only
-  `lang=`.
-- `syllables` gives one count per verse line, not per written line.
+Every target aligns a logical row's cells at the top, including empty ones.
+On a narrow screen or journal, cells stack in their numbered order. A reading
+in a right-to-left face stays in its chosen cell and runs right to left
+within it. The book uses the same row and cell order.
 
-Each finding is an error at the text that is wrong; see
-[a verse in columns](../diagnostics.md#a-worked-case-a-verse-in-columns).
+Findings point to the authored `cols` value, column prefix or inline run;
+see [a verse in columns](../diagnostics.md#a-worked-case-a-verse-in-columns).
 
 ### Scrolls
 
@@ -553,7 +557,7 @@ read from the right, as on a handscroll. A `scroll` fence sets a passage in one
 of these scripts:
 
 ````markdown
-```scroll {rows=25 cols=12 lang=tsu map=tengchou}
+```scroll {rows=25 cols=12 lang=tsu map=tengchou .nativefont}
 chen teng chou hing
 tan tsou dou rou
 
@@ -570,23 +574,24 @@ A scroll fence is a real code fence, so Markdown never reformats its body.
 - **`rows=`** is the number of characters in a column, and **`cols=`** the
   number of columns in a panel. Each is a whole number above zero, and either
   may be left out.
-- **`lang=`, `font=` and `map=`** work as they do on a verse fence. See
+- **`lang=`, `.nativefont`, `font=` and `map=`** work as they do on a verse fence. See
   [marking language, font and mapping](#marking-language-font-and-mapping).
   The text is mapped before it is laid out, so under a
   [logographic map](#logographic-maps) each word is written by its
   characters, one to a morpheme. The map's rows decide what is written
   between words, and a map for a script that runs its characters together
-  writes a space as nothing. If the fence names no `font=`, it takes the face
-  of its map, provided the map is drawn in exactly one face. A fence marked
-  only with a language whose note names its script, such as
-  ` ```scroll {rows=25 cols=12 lang=tsu} `, takes that script's map and face;
+  writes a space as nothing. A scroll requires its own `lang=` and
+  `.nativefont`; its font comes from that language's default or an explicit
+  `font=`, never from the map's list of faces. For example,
+  ` ```scroll {rows=25 cols=12 lang=tsu .nativefont} ` takes Tantsou's
+  configured map and face;
   see [a language's script](#a-languages-script).
 - **The direction comes from the script.** The face's script note states
   `direction: vertical-rl` in its `data.script`; see
   [script notes and emphasis](../reference/format-details.md#script-notes-and-emphasis).
   A script that states no direction is written in lines, and a scroll fence
   set in it is an error. Markup never states a direction itself.
-- **Spans stay horizontal.** A `[…]{lang=… font=… map=…}` span in the same
+- **Spans stay horizontal.** A `[…]{lang=… font=… map=… .nativefont}` span in the same
   script sets its characters left to right, inline, so a short phrase can sit
   in a line of prose.
 
@@ -629,8 +634,8 @@ In the book, a space that a map leaves in the text takes up a whole cell.
 | `` `rows=0` is not a number of characters: `rows=` is a whole number above zero ``                                                                                                               | Write a whole number above zero, or leave the key out.     |
 | `` `cols=two` is not a number of columns: `cols=` is a whole number above zero ``                                                                                                                | Write a whole number above zero, or leave the key out.     |
 | `` `width=` is not a scroll attribute; a scroll takes `rows=`, `cols=`, `lang=`, `font=` and `map=` ``                                                                                           | Remove the key.                                            |
-| ``a `scroll` fence names the face it is set in, with `font=`, a map drawn in one face, with `map=`, or a language whose note names its script in `data.writtenIn`, with `lang=` ``               | Name the face, the map, or a language with a script.       |
-| ``the map `x` is drawn in more than one face; a `scroll` fence names its face with `font=` ``                                                                                                    | Add `font=`.                                               |
+| ``a scroll requires `.nativefont` and an explicit `lang=` on the same construct``                                                                                                                | Add the class and the scroll's language.                   |
+| `` `.nativefont` has no default `font=` for `tsu`; state `font=` explicitly ``                                                                                                                   | Add `font=`, or a font default on the language note.       |
 | ``a `scroll` fence sets a script written in columns, and the script of `semaron-kuriale` is written in lines; set it in a face whose script note states `direction: vertical-rl`, or use a div`` | Set the text in a script written in columns, or use a div. |
 | `scroll fence is empty`, `scroll fence needs a closing code fence`, `` a scroll fence takes no `#id` ``                                                                                          | Write the text, close the fence, or remove the id.         |
 
@@ -639,16 +644,23 @@ has an error is set exactly as written.
 
 ## Marking language, font and mapping
 
-Three keys go in the attribute block a span, a fenced div, a verse fence or a
-[scroll fence](#scrolls) already takes. Each is optional, and each does one thing:
+`lang=` identifies the language. It preserves the authored spelling and the
+surrounding prose font. Add **`.nativefont`** to request native script:
+
+- **`lang=`** names the language and gives the element its language tag.
+  Existing language and vocabulary checks apply in either presentation.
+- **`.nativefont`** requires an explicit `lang=` on that same construct. It
+  selects the language note's `data.writtenIn` map and font. A surrounding
+  language annotation does not satisfy this requirement.
+- **`font=`** overrides the native font independently of the map. Without
+  `.nativefont`, only the Roman families `mono`, `serif` and `sans` are allowed.
+- **`map=`** overrides the native mapping independently of the font and
+  requires `.nativefont`.
 
-- **`lang=`** names the language of the text. It becomes the element's
-  language tag, and where the language's note names
-  [its script](#a-languages-script), the run takes that script's map and face.
-- **`font=`** names the font the text is set in: one of the faces of
-  `@heroiclands/fonts`, or `mono`, `serif` or `sans`.
-- **`map=`** names a [mapping note](#mapping-notes), which rewrites the text
-  before it is set. Without `map=`, the text is set exactly as typed.
+These attributes go on a span, a fenced div, a verse fence or a
+[scroll fence](#scrolls). A native run needs a font from its language or an explicit `font=`. A
+configured map is selected unless `map=` overrides it; without a configured
+or explicit map, directly typed script code points are kept as written. A mismatch between the selected map and font is an error.
 
 A note records Unicode characters. A face draws its own code points, so text in
 a face is either typed in those code points (with a keyboard layout for the
@@ -663,16 +675,41 @@ The greeting at the door is [Daimela, helthos.]{lang=vyl}
 Vylari typed in roman letters, mapped into Semaron Kuriale and set in it:
 
 ```markdown
-The lintel is cut with [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=semaron}.
+The lintel is cut with [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=semaron .nativefont}.
 ```
 
-Text typed in the face's own code points, with a keyboard layout for the face,
-takes no map: `[…]{font=semaron-kuriale}` sets those code points as they are.
+A named reference takes the same keys directly after its wikilink. This
+example identifies the name while retaining Roman spelling:
+
+```markdown
+[Keeper of the open book, ]{lang=en}[[lore-marendasdty|Marendas]]{lang=vyl}[, hear us.]{lang=en}
+```
+
+The reference's language, font and mapping apply to its visible name. Its
+navigation, spoiler styling and draft cue are preserved. Keep surrounding
+prose in adjacent spans, including their spaces and punctuation; a longer
+span of declared-language prose cannot contain a link.
+
+A language-marked reference stays in Roman spelling unless it opts in:
+
+```markdown
+[[lore-marendasdty|Marendas]]{lang=vyl}
+[[lore-marendasdty|Marendas]]{lang=vyl .nativefont}
+```
+
+The second reference uses Vylari's configured native defaults. Its visible name
+alone takes the mapping and font; URLs, Foundry UUIDs, draft cues and book page
+references retain their existing behavior. `.secret` and `.show` work normally.
+
+Text already typed in the script's code points also uses `.nativefont`, an
+explicit language and a font. A configured or explicit map still applies;
+its rows leave code points with no matching row unchanged. Without a map, the
+typed code points reach the font unchanged.
 
 A passage of several paragraphs is a fenced div:
 
 ```markdown
-::: {lang=vyl font=semaron-kuriale map=semaron}
+::: {lang=vyl font=semaron-kuriale map=semaron .nativefont}
 Zaron tholmeza.
 
 Daimela, helthos.
@@ -682,22 +719,29 @@ Daimela, helthos.
 A poem takes the keys on its fence, beside its other attributes:
 
 ````markdown
-```verse {form=epic lang=vyl font=semaron-kuriale map=semaron}
+```verse {form=epic lang=vyl font=semaron-kuriale map=semaron .nativefont}
 Zaron tholmeza,
   daimela, helthos.
 ```
 ````
 
-**A run inside a div or a verse fence inherits its keys**, and its own keys
-override them. Here the gloss keeps the passage's language and map, and is set
-in the page's serif:
+**Unmarked text follows its passage; a marked child chooses its own
+presentation.** A language-only span stays Roman even inside a native passage,
+including when its language matches the passage. To set a child in native
+script, give that child both its own `lang=` and `.nativefont`.
 
 ```markdown
-::: {lang=vyl font=semaron-kuriale map=semaron}
+::: {lang=vyl .nativefont}
 Zaron tholmeza, [an oath, a vow]{lang=en font=serif}.
+[Zaron tholmeza]{lang=vyl} gives the Roman reading.
+[Zaron tholmeza]{lang=vyl .nativefont} gives the native reading.
 :::
 ```
 
+An unmarked span inherits the surrounding language for validation. A child
+`.nativefont` does not inherit its parent's explicit map or font: its own
+language supplies the defaults, and its own overrides choose the alternatives.
+
 ### A language's script
 
 A language note can name the script its language is written in, as one map and
@@ -708,36 +752,35 @@ data:
   writtenIn: { map: semaron, font: semaron-kuriale }
 ```
 
-A run marked with that language alone is then mapped and set as though it named
-both. With Vylari's note stating the default above, these two spans are set
-identically:
+The defaults are used only when the run explicitly opts into native
+presentation. With Vylari's note stating the default above, the first span
+stays Roman and the next two display the same native text:
 
 ```markdown
-The lintel is cut with [Zaron tholmeza]{lang=vyl}.
-The lintel is cut with [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=semaron}.
+[Zaron tholmeza]{lang=vyl}
+[Zaron tholmeza]{lang=vyl .nativefont}
+[Zaron tholmeza]{lang=vyl .nativefont font=semaron-kuriale map=semaron}
 ```
 
-The same holds for a div, a verse fence and a [scroll fence](#scrolls). A run
-fills in what it leaves unstated, and an explicit key overrides its half of the
-default:
+This applies to divs, verse fences, [scroll fences](#scrolls) and standalone
+wikilinks. The overrides are independent:
 
-| The run states             | It takes from the language                                     |
-| -------------------------- | -------------------------------------------------------------- |
-| neither `map=` nor `font=` | the map and the face                                           |
-| `font=` alone              | the map, where the map is drawn in that face; otherwise no map |
-| `map=` alone               | the face, where that map is drawn in it; otherwise no face     |
-| both                       | nothing                                                        |
+| A native run states | It takes from its language  |
+| ------------------- | --------------------------- |
+| neither override    | the configured map and font |
+| `font=` alone       | the configured map          |
+| `map=` alone        | the configured font         |
+| both                | neither default             |
 
-So a language written in more than one script names its usual one in
-`data.writtenIn` and marks a run in another with that script's keys:
-`[Gar-Anlagh]{lang=khel font=qalezu-hand map=qalezu}`. `[Zaron]{lang=vyl
-font=serif}` sets Vylari in the page's serif, unmapped, since Semaron's map is
-not drawn in it.
+A missing font default is an error naming the required `font=` override.
+An incompatible pair is an error; the build does not drop one half or guess a
+replacement. A language written in several scripts states its usual one in
+`data.writtenIn`, then uses both overrides for another:
+`[Gar-Anlagh]{lang=khel .nativefont font=qalezu-hand map=qalezu}`.
 
-The default is the run's own language's, read after a div or fence around the
-run gives it its keys. Inside `::: {lang=vyl}`, a gloss marked
-`[an oath]{lang=en}` takes no face from Vylari. A language whose note states no
-`data.writtenIn` marks its runs with its tag alone.
+`[Zaron]{lang=vyl font=serif}` stays Roman in the page's serif. Adding
+`.nativefont` selects native mapping; a generic Roman font is not an escape
+from the native map/font compatibility check.
 
 `lint` checks the key on the language note: `map` must be the `data.map.name`
 of a mapping note in the package, and `font` one of the faces that map lists.
@@ -767,10 +810,9 @@ an error. Because a tag is checked only for its form, a misspelled name that is
 still a well-formed tag, such as `vly` for `vyl`, is read as the tag of a real
 language. When such a value is within one edit of a declared name (a letter
 added, dropped or changed, two neighbours swapped, or a different case), `lint`
-warns and names the declared language. Text marked with `lang=` alone is not
-checked against any lexicon unless its language names
-[its script](#a-languages-script); a run with `lang=` and a map is, as
-[a mapped run's words](#a-mapped-runs-words) describes.
+warns and names the declared language. A configured language with a `note`
+checks its words whether the run stays Roman or opts into native presentation;
+see [a mapped run's words](#a-mapped-runs-words).
 
 ### What `font=` takes
 
@@ -805,7 +847,12 @@ is one of them.
 
 **With `lang=`, the language's dictionary comes first.** Where
 [`languages.<name>.note`](../configuration.md#languages) names the language's
-note, each word of the run is looked up in its `data.words`:
+note, each word of the run is looked up in its `data.words` and the words of
+its `data.family` chain. The nearest exact NFC form supplies the entire word
+entry, including variants and native spellings; an override replaces the whole
+ancestor entry. Case and word separators remain part of that identity.
+Grammar, registered names and the default writing script remain the daughter's
+own. An inherited native spelling applies only to the map and face it names:
 
 1. **A word whose entry states a `native` form for the map** is written by it:
    the form stated for the run's face where there is one, else the form stated
@@ -824,8 +871,9 @@ form that begins otherwise cannot be capitalised by the rows, and the
 capitalised word is an error; state it as a word of its own, `Orlan` beside
 `orlan`, with its own native form.
 
-With `map=` and no `lang=`, a bare tag, or a declared language with no `note`,
-the rows alone apply.
+A native run with an explicit bare BCP 47 tag, such as `lang=und`, or a
+declared language with no `note`, uses the rows alone. It still requires
+`.nativefont` and an effective font.
 
 Take Vylari's `zaron`, an oath, written in Semaron. With no exception stated,
 the rows spell it letter by letter, as they spell any word:
@@ -838,7 +886,7 @@ the rows spell it letter by letter, as they spell any word:
 ```
 
 Where the chancery writes the word another way, the entry states that once,
-and `[zaron]{lang=vyl font=semaron-kuriale map=semaron}` is written by it:
+and `[zaron]{lang=vyl font=semaron-kuriale map=semaron .nativefont}` is written by it:
 
 ```yaml
 - form: zaron
@@ -858,7 +906,7 @@ vyl zaron` converts a passage, both through the build's own code; see
 
 ### A mapped run's words
 
-**Every word of a run with `lang=` and `map=` is a word of its language**, where
+**Every word of a run with `lang=` is a word of its language**, where
 the language's [`note`](../configuration.md#languages) names its language note.
 Each word, case folded, is one of:
 
@@ -966,8 +1014,7 @@ register:
   - { name: Revothar Baremzator, tongue: vylari }
 ```
 
-A run with `lang=` and no `map=`, a run with `map=` and no
-`lang=`, a bare BCP 47 tag and a declared language with no `note` are not
+A bare BCP 47 tag and a declared language with no `note` are not
 checked.
 
 ### Logographic maps
@@ -1037,7 +1084,7 @@ words:
     built: [halzi, -unet]
 ```
 
-`[halzi halzunet halziim]{lang=khel font=khelathi-zethu-glyphs map=zethu}` is
+`[halzi halzunet halziim]{lang=khel font=khelathi-zethu-glyphs map=zethu .nativefont}` is
 written U+1EABB, then U+1EABB U+1EBC7, then U+1EABB U+1EBE1, with the spaces
 the rows write between them. A word of the run that resolves to nothing is
 reported once per run:
@@ -1140,14 +1187,14 @@ finding the lint reports in `data.map`.
 Every target rewrites marked text first, so a page, a Foundry journal and a
 book all show the same thing.
 
-| Marking                                | The text                           | The element                                                               |
-| -------------------------------------- | ---------------------------------- | ------------------------------------------------------------------------- |
-| `lang=` alone                          | As written                         | Tagged with the language's tag, `lang="art-x-vyl"`                        |
-| `map=`                                 | Rewritten by the map, line by line | As below                                                                  |
-| `font=` a face                         | As written, or as the map wrote it | The tag, `script` and the face's class; not indexed by the site's search  |
-| `font=mono`, `serif`, `sans`           | As written, or as the map wrote it | The tag and `font-mono`, `font-serif` or `font-sans`                      |
-| A div or fence in a right-to-left face | As above                           | Also `dir="rtl"`; a div also carries `script-block`                       |
-| A scroll fence                         | Each paragraph on one line         | `scroll`, the tag, `script` and the face's class; see [scrolls](#scrolls) |
+| Marking                                | The text                                      | The element                                                               |
+| -------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------- |
+| `lang=` alone                          | As written                                    | Tagged with the language's tag, `lang="art-x-vyl"`                        |
+| `lang=… .nativefont`                   | Rewritten by the configured or overridden map | Native font and language tag                                              |
+| `lang=… .nativefont font=…`            | Mapped text                                   | The tag, `script` and the face's class; not indexed by the site's search  |
+| `font=mono`, `serif`, `sans`           | As written, or as the map wrote it            | The tag and `font-mono`, `font-serif` or `font-sans`                      |
+| A div or fence in a right-to-left face | As above                                      | Also `dir="rtl"`; a div also carries `script-block`                       |
+| A scroll fence                         | Each paragraph on one line                    | `scroll`, the tag, `script` and the face's class; see [scrolls](#scrolls) |
 
 No target writes `<bdo>`, `<bdi>` or a Unicode direction control character: a
 right-to-left face's code points carry their own direction. Text with an error
@@ -1162,10 +1209,12 @@ alone. A block or verse in a right-to-left face is set right to left.
 Text marked with `font=` or `map=`, or with a language the package declares, is
 plain text.
 
-- **A span or a verse line** holds no emphasis, link, image, footnote,
-  wikilink, code or HTML, and no span but a marked one inside a div or a fence.
-  Text set in a face is the one exception: it takes `*…*` and `**…**`, as
-  [emphasis in a script](#emphasis-in-a-script) describes.
+- **A span or a verse line** holds no link, image, footnote, wikilink, code or
+  HTML, and no unmarked nested span. Marked spans may be nested. English may
+  use Markdown emphasis; emphasis inside a span with an effective non-English
+  language is an error. A standalone wikilink may carry language, font and map
+  keys directly after it, as above; only its label is set. See [emphasis in a
+  script](#emphasis-in-a-script).
 - **A div** holds paragraphs and line breaks only: no heading, list, block
   quote, code fence, verse fence, table, rule, footnote definition or nested
   block. Mark a poem's own fence instead of a div around it.
@@ -1177,7 +1226,13 @@ and a doubled `[[` a wikilink. `[^id]` is a footnote only where the note
 defines `[^id]:`. A bracket with no partner takes a backslash, `\[`.
 
 Text marked with a real language's tag alone keeps its Markdown, so
-`[ad _astra_]{lang=la}` and an English poem with emphasis are both accepted.
+English text and spans may use emphasis. Any actual bold or italic Markdown
+inside a span whose effective language is not English is an error, whether the
+span marks a real language or an invented one, and whether it declares the
+language itself or inherits it from a surrounding div or fence. English (`en`)
+and English BCP 47 tags such as `en-US` remain eligible. Escaped delimiter
+characters are literal text, not emphasis. This restriction applies throughout
+the note, including outside verse.
 
 ### Emphasis in a script
 
@@ -1212,26 +1267,17 @@ data:
 ---
 ```
 
-So a tongue that states nothing takes its script's convention. Provenzal set in
-Semaron is rubric:
-
-```markdown
-The lintel reads [a _stressed_ word]{lang=prv font=semaron-kuriale map=semaron}.
-```
-
-and renders on the site as
-
-```html
-<span class="script hl-semaron-kuriale" lang="art-x-prv" data-pagefind-ignore="true"
-  >… <em class="emph-rubric">…</em> …</span
->
-```
+So a tongue that states nothing takes its script's convention. A script may
+still define how accepted emphasis renders, but a span with an effective
+non-English language cannot use Markdown emphasis even when that convention is
+`rubric` or `overline`.
 
 **A language may mark emphasis with a word** instead of a mark:
 `data.emphasis: words` on its language note. Emphasis in a run of that language
-is then an error at the emphasis, and the remedy is the word the language
-stresses with. A language may also state `rubric` or `overline`, which it takes
-in every script it is written in.
+is an error; for a non-English language, the span restriction also applies
+regardless of its `data.emphasis` value. A language may state `rubric` or
+`overline`, which it takes in every script it is written in, but marked
+emphasis remains disallowed inside its non-English spans.
 
 `_…_` is emphasis equal to `*…*`, and `__…__` equal to `**…**`, so a note keeps
 its meaning when a formatter rewrites one pair to the other. A strikethrough is
@@ -1262,8 +1308,7 @@ that `lint` reports and that fails nothing:
 | `` `halzi` has no `zethu` writing: the map `zethu` is logographic, and the run names no `lang=` whose lexicon writes it; mark the run with its language, or write the word directly in signs ``                                                                | Mark the run with `lang=`, or write its signs directly.                                                                   |
 | `` `thiruthrimar` is not a word of the `vyl` lexicon, a registered name, or a regular form of one; coin it in the lexicon (or register the name) first ``                                                                                                      | Coin the word in the language note's `data.words`, register the name in its own `data.register`, or correct the spelling. |
 | `` `thuravark-carved` is not a font of the map `semaron`; it is for `semaron-kuriale` ``                                                                                                                                                                       | Set the run in a face the map lists, or list the face in `data.map.fonts`.                                                |
-| ``text marked `lang=vyl` is plain text and holds no emphasis``                                                                                                                                                                                                 | Remove the markup, or escape the character with a backslash.                                                              |
-| ``text marked `lang=prv font=semaron-kuriale map=semaron` takes emphasis only as `*…*`, `_…_`, `**…**` or `__…__` ``                                                                                                                                           | Write the emphasis with stars or underscores.                                                                             |
+| ``a span in non-English language `vyl` holds no bold or italic markup``                                                                                                                                                                                        | Remove the markup, or escape its delimiter characters.                                                                    |
 | `` `vyl` marks emphasis with a word, not a mark; write the word ``                                                                                                                                                                                             | Remove the emphasis marks and write the word the language stresses with.                                                  |
 | ``a div marked `lang=vyl font=semaron-kuriale map=semaron` holds paragraphs and line breaks only, not a list``                                                                                                                                                 | Move the list out of the div.                                                                                             |
 | `` `font=` is read on a span, a div or a verse fence, not on a secret block ``                                                                                                                                                                                 | Put a marked div inside the secret block.                                                                                 |